solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const long long LINF = 1e18;
const double FINF = 1e15;
const double EPS = 1e-9;
const double PI = 2.0 * acos(0.0);
long long dp[3005][3005];
int a[3005], b[3005];
int n;
inline void asmin(long long& a, long long b) {
if (a > b) a = b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] -= i;
b[i] = a[i];
}
sort(b + 1, b + n + 1);
b[0] = b[1];
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j) dp[i][j] = LINF;
dp[0][0] = 0;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
if (i + 1 <= n) {
asmin(dp[i + 1][j], dp[i][j] + abs(a[i + 1] - b[j]));
}
if (j + 1 <= n) {
asmin(dp[i][j + 1], dp[i][j]);
}
}
}
long long ans = LINF;
for (int i = 1; i <= n; ++i) asmin(ans, dp[n][i]);
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int cn = 0;
cin >> s;
for (int i = 0; s[i] != '\0'; i++) {
if (s[i] == '4' || s[i] == '7') cn++;
}
if (cn == 4 || cn == 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, num[100005], num2[100005];
int v1[100005], v2[100005];
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
if (!v1[num[i]])
v1[num[i]]++;
else {
printf("0");
return 0;
}
}
for (int i = 1; i <= n; i++) {
num2[i] = num[i] & x;
if (num[i] == num2[i]) continue;
if (v1[num2[i]]) {
printf("1");
return 0;
} else
v2[num2[i]]++;
}
for (int i = 0; i <= 100000; i++) {
if (v2[i] >= 2) {
printf("2");
return 0;
}
}
printf("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238462643383;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int Ceil(long long int a, long long int b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
const int MAX = 200009;
const int MOD = 1e9 + 7;
const int inf = 1e9 + 10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> arr(n, 0);
for (int i = 0; i < (n); ++i) {
cin >> arr[i];
}
int mi = 100 * 1000;
int min_k = 0;
for (int k = 0; k < 101; k++) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum +=
min(abs(arr[i] - k), min(abs(arr[i] - k - 1), abs(arr[i] - k + 1)));
}
mi = min(mi, sum);
if (mi == sum) min_k = k;
}
cout << min_k << " " << mi;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, q;
int a[5010];
int val[5010][5010];
int maxv[5010][5010];
int imax(int a, int b) { return a > b ? a : b; }
int main() {
int i, j, l, r;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) val[i][i] = maxv[i][i] = a[i];
for (i = 2; i <= n; i++)
for (j = 1; j <= n - i + 1; j++) {
val[j][j + i - 1] = val[j][j + i - 2] ^ val[j + 1][j + i - 1];
maxv[j][j + i - 1] = imax(maxv[j][j + i - 2], maxv[j + 1][j + i - 1]);
maxv[j][j + i - 1] = imax(maxv[j][j + i - 1], val[j][j + i - 1]);
}
scanf("%d", &q);
while (q--) {
scanf("%d %d", &l, &r);
printf("%d\n", maxv[l][r]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
using pll = pair<ll, ll>;
const int N = 2e2 + 2;
int a[N][N];
struct Node {
int x1, y1;
int x2, y2;
int x3, y3;
Node() {}
Node(int x1, int y1, int x2, int y2, int x3, int y3)
: x1(x1), y1(y1), x2(x2), y2(y2), x3(x3), y3(y3) {}
};
vector<Node> ve;
void process(int n, int m) {
int x1 = a[n - 2][m - 2];
int x2 = a[n - 2][m - 1];
int x3 = a[n - 1][m - 2];
int x4 = a[n - 1][m - 1];
if (x1 + x2 + x3 + x4 == 1) {
if (x1 == 1) {
ve.push_back({n - 2, m - 2, n - 1, m - 1, n - 2, m - 1});
a[n - 2][m - 2] ^= 1;
a[n - 1][m - 1] ^= 1;
a[n - 2][m - 1] ^= 1;
} else if (x2 == 1) {
ve.push_back({n - 2, m - 2, n - 1, m - 1, n - 2, m - 1});
a[n - 2][m - 2] ^= 1;
a[n - 1][m - 1] ^= 1;
a[n - 2][m - 1] ^= 1;
} else if (x3 == 1) {
ve.push_back({n - 1, m - 2, n - 2, m - 2, n - 2, m - 1});
a[n - 2][m - 2] ^= 1;
a[n - 1][m - 2] ^= 1;
a[n - 2][m - 1] ^= 1;
} else if (x4 == 1) {
ve.push_back({n - 2, m - 2, n - 1, m - 1, n - 2, m - 1});
a[n - 2][m - 2] ^= 1;
a[n - 1][m - 1] ^= 1;
a[n - 2][m - 1] ^= 1;
}
}
x1 = a[n - 2][m - 2];
x2 = a[n - 2][m - 1];
x3 = a[n - 1][m - 2];
x4 = a[n - 1][m - 1];
if (x1 + x2 + x3 + x4 == 2) {
if (x1 == 1 && x2 == 1) {
ve.push_back({n - 2, m - 2, n - 1, m - 1, n - 1, m - 2});
a[n - 2][m - 2] ^= 1;
a[n - 1][m - 1] ^= 1;
a[n - 1][m - 2] ^= 1;
} else if (x1 == 1 && x3 == 1) {
ve.push_back({n - 2, m - 2, n - 1, m - 1, n - 2, m - 1});
a[n - 2][m - 2] ^= 1;
a[n - 1][m - 1] ^= 1;
a[n - 2][m - 1] ^= 1;
} else if (x1 == 1 && x4 == 1) {
ve.push_back({n - 2, m - 2, n - 2, m - 1, n - 1, m - 2});
a[n - 2][m - 2] ^= 1;
a[n - 2][m - 1] ^= 1;
a[n - 1][m - 2] ^= 1;
} else if (x2 == 1 && x3 == 1) {
ve.push_back({n - 2, m - 2, n - 1, m - 1, n - 1, m - 2});
a[n - 2][m - 2] ^= 1;
a[n - 1][m - 1] ^= 1;
a[n - 1][m - 2] ^= 1;
} else if (x2 == 1 && x4 == 1) {
ve.push_back({n - 2, m - 2, n - 2, m - 1, n - 1, m - 2});
a[n - 2][m - 2] ^= 1;
a[n - 2][m - 1] ^= 1;
a[n - 1][m - 2] ^= 1;
} else if (x3 == 1 && x4 == 1) {
ve.push_back({n - 2, m - 2, n - 2, m - 1, n - 1, m - 2});
a[n - 2][m - 2] ^= 1;
a[n - 2][m - 1] ^= 1;
a[n - 1][m - 2] ^= 1;
}
}
x1 = a[n - 2][m - 2];
x2 = a[n - 2][m - 1];
x3 = a[n - 1][m - 2];
x4 = a[n - 1][m - 1];
if (x1 + x2 + x3 + x4 == 3) {
if (x1 == 0) {
ve.push_back({n - 1, m - 2, n - 2, m - 1, n - 1, m - 1});
a[n - 1][m - 2] ^= 1;
a[n - 2][m - 1] ^= 1;
a[n - 1][m - 1] ^= 1;
} else if (x2 == 0) {
ve.push_back({n - 1, m - 2, n - 2, m - 2, n - 1, m - 1});
a[n - 1][m - 2] ^= 1;
a[n - 2][m - 2] ^= 1;
a[n - 1][m - 1] ^= 1;
} else if (x3 == 0) {
ve.push_back({n - 2, m - 2, n - 2, m - 1, n - 1, m - 1});
a[n - 2][m - 2] ^= 1;
a[n - 2][m - 1] ^= 1;
a[n - 1][m - 1] ^= 1;
} else if (x4 == 0) {
ve.push_back({n - 1, m - 2, n - 2, m - 1, n - 2, m - 2});
a[n - 1][m - 2] ^= 1;
a[n - 2][m - 1] ^= 1;
a[n - 2][m - 2] ^= 1;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
ve.clear();
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
a[i][j] = c - '0';
}
}
for (int i = 0; i + 1 < n; i++) {
for (int j = 0; j + 1 < m; j++) {
int x1 = a[i][j];
int x2 = a[i][j + 1];
int x3 = a[i + 1][j];
int x4 = a[i + 1][j + 1];
if (x1 + x2 + x3 + x4 == 0) continue;
if (x1 + x2 == 0) continue;
if (x1 == 0) {
ve.push_back({i + 1, j, i, j + 1, i + 1, j + 1});
a[i + 1][j] ^= 1;
a[i + 1][j + 1] ^= 1;
a[i][j + 1] ^= 1;
} else if (x2 == 0) {
ve.push_back({i, j, i + 1, j + 1, i + 1, j});
a[i + 1][j] ^= 1;
a[i][j] ^= 1;
a[i + 1][j + 1] ^= 1;
} else if (x3 == 0) {
ve.push_back({i, j, i, j + 1, i + 1, j + 1});
a[i][j] ^= 1;
a[i][j + 1] ^= 1;
a[i + 1][j + 1] ^= 1;
} else {
ve.push_back({i, j, i, j + 1, i + 1, j});
a[i][j] ^= 1;
a[i][j + 1] ^= 1;
a[i + 1][j] ^= 1;
}
}
}
for (int j = 2; j <= m; j++) {
process(n, j);
}
assert(ve.size() <= 3 * n * m);
cout << ve.size() << "\n";
for (Node x : ve) {
cout << x.x1 + 1 << " " << x.y1 + 1 << " " << x.x2 + 1 << " " << x.y2 + 1
<< " " << x.x3 + 1 << " " << x.y3 + 1 << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int h[200005], nxt[200005], Fa[200005], g[200005];
int s[200005], E[200005][3], fa[200005][20];
int dep[200005], d[200005], f[200005], n, m;
vector<int> q[200005];
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 17; i >= 0; i--)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
for (int i = 17; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return x == y ? x : fa[x][0];
}
int get(int x) {
int m = 1;
d[1] = x;
for (; Fa[x] > 0; d[++m] = x = Fa[x])
;
for (int i = m - 1; i; i--) Fa[d[i]] = d[m], g[d[i]] += g[d[i + 1]];
return d[m];
}
int main() {
scanf("%d%d", &n, &m);
dep[1] = 1;
for (int i = 2; i <= n; i++) {
scanf("%d", &fa[i][0]);
nxt[i] = h[fa[i][0]];
h[fa[i][0]] = i;
dep[i] = dep[fa[i][0]] + 1;
}
for (int j = 1; j < 18; j++)
for (int i = 1; i <= n; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &E[i][0], &E[i][1], &E[i][2]);
q[lca(E[i][0], E[i][1])].push_back(i);
}
for (int i = n; i; i--) {
for (int j = 0; j < q[i].size(); j++) {
int k = q[i][j], x = get(E[k][0]), y = get(E[k][1]), v = E[k][2];
if (y != i) v += -f[y] + s[E[k][1]] + g[E[k][1]];
if (x != i) v += -f[x] + s[E[k][0]] + g[E[k][0]];
f[i] = max(f[i], v);
}
for (int j = h[i]; j; j = nxt[j]) s[i] += f[j], Fa[j] = i;
f[i] += s[i];
for (int j = h[i]; j; j = nxt[j]) g[j] += s[i] - f[j];
}
printf("%d", f[1]);
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, m;
std::cin >> n >> m;
std::set<int> s;
std::vector<int> a(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
}
for (int j = 0; j < m; ++j) {
int x;
std::cin >> x;
s.insert(x);
}
std::vector<int> ans;
for (auto i : a) {
if (s.find(i) != s.end()) {
ans.push_back(i);
}
}
for (int i = 0; i < ans.size(); ++i) {
std::cout << ans[i] << ' ';
}
std::cout << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace jenga {
inline char get_unempty_char() {
char ch;
while (isspace(ch = getchar()))
;
return ch;
}
const double eps(1e-10), Inf = 1e+64;
const int RED = 1, BLUE = 2, GREEN = 3, EMPTY = 0, N = 6, Base = 67,
mod = 1 << 22;
int n, last[mod] = {}, next[mod] = {}, total_edge = 0, s[N * 3 - 1] = {},
tot = 0;
unsigned long long hv[mod] = {};
double f[mod] = {};
inline void add(unsigned long long hash, double v) {
int u = hash % mod;
next[++total_edge] = last[u];
last[u] = total_edge;
f[total_edge] = v;
hv[total_edge] = hash;
}
inline int get_num(char ch) {
if (ch == 'R') return RED;
if (ch == 'B') return BLUE;
if (ch == 'G') return GREEN;
if (ch == 'E') return EMPTY;
assert(false);
}
void init() {
n = get_unempty_char() - '0';
for (int i = 1; i <= n; ++i) {
s[i] |= get_num(get_unempty_char()) << 0;
s[i] |= get_num(get_unempty_char()) << 2;
s[i] |= get_num(get_unempty_char()) << 4;
}
tot = n;
}
inline unsigned long long hash(int *s, int k, int up) {
static int v[N * 3 + 10] = {};
unsigned long long h = 0;
int tot = 0;
for (int i = 1; i <= k; ++i) {
int c1 = (s[i] >> 4) & 3, c2 = (s[i]) & 3, c3 = (s[i] >> 2) & 3;
v[++tot] =
c1 > c2 ? (c3 << 2) | c1 | (c2 << 4) : (c3 << 2) | c2 | (c1 << 4);
}
sort(v + 1, v + tot + 1);
int c1 = (up >> 4) & 3, c2 = up & 3, c3 = (up >> 2) & 3;
if (c1 > c2) up = c1 | (c2 << 4) | (c3 << 2);
for (int i = 1; i <= tot; ++i) h = h * Base + v[i];
h = h * Base + up;
return h;
}
double work(int *s, int tot, int up) {
unsigned long long h = hash(s, tot, up);
for (int i = last[h % mod]; i; i = next[i])
if (hv[i] == h) return f[i];
double v[4] = {Inf, Inf, Inf, Inf};
int to = tot, D = 6;
if ((up & 3) && ((up >> 2) & 3) && ((up >> 4) & 3)) s[++to] = up, up = 0;
for (int i = 1; i <= tot; ++i) {
int c1 = s[i] & 3, c2 = (s[i] >> 2) & 3, c3 = (s[i] >> 4) & 3, ns = s[i];
if (c1 && c2 && c3 && v[c2] > eps) {
s[i] = 0;
if (!(up & 3))
v[c2] = min(v[c2], work(s, to, up | c2));
else if (!(up >> 4 & 3))
v[c2] = min(v[c2], work(s, to, up | c2 << 4));
if (!(up >> 2 & 3)) v[c2] = min(v[c2], work(s, to, up | c2 << 2));
s[i] = ns;
}
if (c1 && c2 && v[c1] > eps) {
s[i] = c3 == 0 ? 0 : s[i] & ~3;
if (!(up & 3))
v[c1] = min(v[c1], work(s, to, up | c1));
else if (!(up >> 4 & 3))
v[c1] = min(v[c1], work(s, to, up | c1 << 4));
if (!(up >> 2 & 3)) v[c1] = min(v[c1], work(s, to, up | c1 << 2));
s[i] = ns;
}
if (c2 && c3 && v[c3] > eps) {
s[i] = c1 == 0 ? 0 : s[i] & ~48;
if (!(up & 3))
v[c3] = min(v[c3], work(s, to, up | c3));
else if (!(up >> 4 & 3))
v[c3] = min(v[c3], work(s, to, up | c3 << 4));
if (!(up >> 2 & 3)) v[c3] = min(v[c3], work(s, to, up | c3 << 2));
s[i] = ns;
}
}
double sum = 0;
if (v[1] != Inf) sum += v[1], D -= 1;
if (v[2] != Inf) sum += v[2] * 2, D -= 2;
if (v[3] != Inf) sum += v[3] * 2, D -= 2;
sum = D == 6 ? 0 : (sum + 6) / (6 - D);
add(h, sum);
return sum;
}
int Main() {
init();
printf("%.15f\n", work(s, tot - 1, s[tot]));
return 0;
}
} // namespace jenga
int main() {
jenga::Main();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, j, a[35005], dp[51][35005], pre[35005], last[35005];
int aint[132000], lazy[132000], pos[35005];
unordered_set<int> S;
void update(int k) {
aint[k] = max(aint[k << 1], aint[(k << 1) + 1]) + lazy[k];
if (k > 1) update(k >> 1);
}
void update_lazy(int k, int x, int y, int a, int b) {
if (x >= a && y <= b) {
lazy[k]++;
aint[k]++;
} else {
int m = (x + y) >> 1;
if (a <= m) update_lazy(k << 1, x, m, a, b);
if (b > m) update_lazy((k << 1) + 1, m + 1, y, a, b);
aint[k] = max(aint[k << 1], aint[(k << 1) + 1]) + lazy[k];
}
}
int query(int k, int x, int y, int a, int b) {
if (x >= a && y <= b)
return aint[k];
else {
int m = (x + y) >> 1, q = 0, w = 0;
if (a <= m) q = query(k << 1, x, m, a, b);
if (b > m) w = query((k << 1) + 1, m + 1, y, a, b);
return lazy[k] + max(q, w);
}
}
void build(int k, int x, int y) {
if (x == y)
pos[x] = k;
else {
int m = (x + y) >> 1;
build(k << 1, x, m);
build((k << 1) + 1, m + 1, y);
}
}
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
S.insert(a[i]);
dp[1][i] = S.size();
}
for (i = 1; i <= n; i++) {
pre[i] = last[a[i]];
last[a[i]] = i;
}
build(1, 1, n);
for (j = 2; j <= k; j++) {
memset(aint, 0, sizeof(aint));
memset(lazy, 0, sizeof(lazy));
S.clear();
S.insert(a[j]);
for (i = j - 1; i >= 1; i--) {
aint[pos[i]] = dp[j - 1][i] + S.size();
update(pos[i] >> 1);
S.insert(a[i]);
}
for (i = j; i <= n; i++) {
dp[j][i] = query(1, 1, n, 1, i - 1);
if (pre[i + 1] <= i - 1) update_lazy(1, 1, n, pre[i + 1], i - 1);
aint[pos[i]] = dp[j - 1][i] + 1;
update(pos[i] >> 1);
}
}
cout << dp[k][n];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream &operator<<(ostream &os, const T_container &v) {
os << '{';
string sep;
for (const T &x : v) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
template <typename T, bool maximum_mode = false>
struct RMQ {
int n = 0;
vector<T> values;
vector<vector<int>> range_low;
RMQ(const vector<T> &_values = {}) {
if (!_values.empty()) build(_values);
}
static int largest_bit(int x) { return x == 0 ? -1 : 31 - __builtin_clz(x); }
int better_index(int a, int b) const {
return (maximum_mode ? values[b] < values[a] : values[a] < values[b]) ? a
: b;
}
void build(const vector<T> &_values) {
values = _values;
n = int(values.size());
int levels = largest_bit(n) + 1;
range_low.resize(levels);
for (int k = 0; k < levels; k++) range_low[k].resize(n - (1 << k) + 1);
for (int i = 0; i < n; i++) range_low[0][i] = i;
for (int k = 1; k < levels; k++)
for (int i = 0; i <= n - (1 << k); i++)
range_low[k][i] = better_index(range_low[k - 1][i],
range_low[k - 1][i + (1 << (k - 1))]);
}
int query_index(int a, int b) const {
assert(0 <= a && a < b && b <= n);
int level = largest_bit(b - a);
return better_index(range_low[level][a],
range_low[level][b - (1 << level)]);
}
T query_value(int a, int b) const { return values[query_index(a, b)]; }
};
struct LCA {
int n = 0;
vector<vector<int>> adj;
vector<int> parent, depth, subtree_size;
vector<int> euler, first_occurrence;
vector<int> tour_start, tour_end, postorder;
vector<int> tour_list, rev_tour_list;
vector<int> heavy_root;
RMQ<int> rmq;
bool built;
LCA(int _n = 0) { init(_n); }
LCA(const vector<vector<int>> &_adj) { init(_adj); }
void init(int _n) {
n = _n;
adj.assign(n, {});
parent.resize(n);
depth.resize(n);
subtree_size.resize(n);
first_occurrence.resize(n);
tour_start.resize(n);
tour_end.resize(n);
postorder.resize(n);
tour_list.resize(n);
heavy_root.resize(n);
built = false;
}
void init(const vector<vector<int>> &_adj) {
init(int(_adj.size()));
adj = _adj;
}
void add_edge(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
}
int degree(int v) const {
return int(adj[v].size()) + (built && parent[v] >= 0);
}
void dfs(int node, int par) {
parent[node] = par;
depth[node] = par < 0 ? 0 : depth[par] + 1;
subtree_size[node] = 1;
adj[node].erase(remove(adj[node].begin(), adj[node].end(), par),
adj[node].end());
for (int child : adj[node]) {
dfs(child, node);
subtree_size[node] += subtree_size[child];
}
sort(adj[node].begin(), adj[node].end(),
[&](int a, int b) { return subtree_size[a] > subtree_size[b]; });
}
int tour, post_tour;
void tour_dfs(int node, bool heavy) {
heavy_root[node] = heavy ? heavy_root[parent[node]] : node;
first_occurrence[node] = int(euler.size());
euler.push_back(node);
tour_list[tour] = node;
tour_start[node] = tour++;
bool heavy_child = true;
for (int child : adj[node]) {
tour_dfs(child, heavy_child);
euler.push_back(node);
heavy_child = false;
}
tour_end[node] = tour;
postorder[node] = post_tour++;
}
void build(int root = -1, bool build_rmq = true) {
parent.assign(n, -1);
if (0 <= root && root < n) dfs(root, -1);
for (int i = 0; i < n; i++)
if (i != root && parent[i] < 0) dfs(i, -1);
tour = post_tour = 0;
euler.clear();
euler.reserve(2 * n);
for (int i = 0; i < n; i++)
if (parent[i] < 0) {
tour_dfs(i, false);
euler.push_back(-1);
}
rev_tour_list = tour_list;
reverse(rev_tour_list.begin(), rev_tour_list.end());
assert(int(euler.size()) == 2 * n);
vector<int> euler_depths;
euler_depths.reserve(euler.size());
for (int node : euler)
euler_depths.push_back(node < 0 ? node : depth[node]);
if (build_rmq) rmq.build(euler_depths);
built = true;
}
vector<pair<int, array<int, 2>>> get_diameters() const {
assert(built);
pair<int, int> u_max = {-1, -1};
pair<int, int> ux_max = {-1, -1};
pair<int, array<int, 2>> uxv_max = {-1, {-1, -1}};
vector<pair<int, array<int, 2>>> diameters;
for (int node : euler) {
if (node < 0) {
diameters.push_back(uxv_max);
u_max = ux_max = {-1, -1};
uxv_max = {-1, {-1, -1}};
continue;
}
u_max = max(u_max, {depth[node], node});
ux_max = max(ux_max, {u_max.first - 2 * depth[node], u_max.second});
uxv_max =
max(uxv_max, {ux_max.first + depth[node], {ux_max.second, node}});
}
return diameters;
}
int get_lca(int a, int b) const {
a = first_occurrence[a];
b = first_occurrence[b];
if (a > b) swap(a, b);
return euler[rmq.query_index(a, b + 1)];
}
bool is_ancestor(int a, int b) const {
return tour_start[a] <= tour_start[b] && tour_start[b] < tour_end[a];
}
bool on_path(int x, int a, int b) const {
return (is_ancestor(x, a) || is_ancestor(x, b)) &&
is_ancestor(get_lca(a, b), x);
}
int get_dist(int a, int b) const {
return depth[a] + depth[b] - 2 * depth[get_lca(a, b)];
}
int child_ancestor(int a, int b) const {
assert(a != b);
assert(is_ancestor(a, b));
int child =
euler[rmq.query_index(first_occurrence[a], first_occurrence[b] + 1) +
1];
assert(parent[child] == a);
assert(is_ancestor(child, b));
return child;
}
int get_kth_ancestor(int a, int k) const {
while (a >= 0) {
int root = heavy_root[a];
if (depth[root] <= depth[a] - k) return tour_list[tour_start[a] - k];
k -= depth[a] - depth[root] + 1;
a = parent[root];
}
return a;
}
int get_kth_node_on_path(int a, int b, int k) const {
int anc = get_lca(a, b);
int first_half = depth[a] - depth[anc];
int second_half = depth[b] - depth[anc];
assert(0 <= k && k <= first_half + second_half);
if (k < first_half)
return get_kth_ancestor(a, k);
else
return get_kth_ancestor(b, first_half + second_half - k);
}
int get_common_node(int a, int b, int c) const {
int x = get_lca(a, b);
int y = get_lca(b, c);
int z = get_lca(c, a);
x = depth[y] > depth[x] ? y : x;
x = depth[z] > depth[x] ? z : x;
return x;
}
vector<pair<int, int>> compress_tree(vector<int> nodes) const {
if (nodes.empty()) return {};
auto &&compare_tour = [&](int a, int b) {
return tour_start[a] < tour_start[b];
};
sort(nodes.begin(), nodes.end(), compare_tour);
int k = int(nodes.size());
for (int i = 0; i < k - 1; i++)
nodes.push_back(get_lca(nodes[i], nodes[i + 1]));
sort(nodes.begin() + k, nodes.end(), compare_tour);
inplace_merge(nodes.begin(), nodes.begin() + k, nodes.end(), compare_tour);
nodes.erase(unique(nodes.begin(), nodes.end()), nodes.end());
vector<pair<int, int>> result = {{nodes[0], -1}};
for (int i = 1; i < int(nodes.size()); i++)
result.emplace_back(nodes[i], get_lca(nodes[i], nodes[i - 1]));
return result;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << setprecision(9);
int N, M, Q;
cin >> N >> M >> Q;
LCA lca(N);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
lca.add_edge(u, v);
}
lca.build();
vector<int> root(N, -1);
for (int x : lca.tour_list)
root[x] = lca.parent[x] < 0 ? x : root[lca.parent[x]];
vector<array<int, 2>> diameters(N, {-1, -1});
vector<pair<int, array<int, 2>>> diam_list = lca.get_diameters();
for (auto &pr : diam_list) diameters[root[pr.second[0]]] = pr.second;
vector<vector<int>> farthest(N);
for (int i = 0; i < N; i++) {
int r = root[i];
int dist =
max(lca.get_dist(i, diameters[r][0]), lca.get_dist(i, diameters[r][1]));
farthest[r].push_back(dist);
}
vector<vector<int64_t>> suffix_sum(N);
for (int i = 0; i < N; i++) {
int C = int(farthest[i].size());
if (C == 0) continue;
sort(farthest[i].begin(), farthest[i].end());
suffix_sum[i].assign(C + 1, 0);
for (int c = C - 1; c >= 0; c--)
suffix_sum[i][c] = suffix_sum[i][c + 1] + farthest[i][c];
}
map<int64_t, double> save;
auto compute_answer = [&](int a, int b) -> double {
if (a == b) return -1;
int64_t key = int64_t(min(a, b)) << 32 | max(a, b);
if (save.find(key) != save.end()) return save[key];
if (farthest[a].size() > farthest[b].size()) swap(a, b);
int n = int(farthest[a].size()), m = int(farthest[b].size());
int larger = max(farthest[a].back(), farthest[b].back());
int64_t sum = 0;
const int JUMP = m / n + 1;
for (int i = n - 1, index = 0; i >= 0; i--) {
int x = farthest[a][i];
int goal = larger - x;
int high = index;
while (high < m && farthest[b][high] < goal) {
index = high;
high = min(high + JUMP, m);
}
index = int(lower_bound(farthest[b].begin() + index,
farthest[b].begin() + high, goal) -
farthest[b].begin());
sum += int64_t(index) * larger + int64_t(m - index) * (x + 1) +
suffix_sum[b][index];
}
return save[key] = double(sum) / (double(n) * m);
};
for (int q = 0; q < Q; q++) {
int u, v;
cin >> u >> v;
u--;
v--;
cout << compute_answer(root[u], root[v]) << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<string, long> m;
map<long, string> m1;
m["S"] = 0;
m["M"] = 1;
m["L"] = 2;
m["XL"] = 3;
m["XXL"] = 4;
m1[0] = "S";
m1[1] = "M";
m1[2] = "L";
m1[3] = "XL";
m1[4] = "XXL";
vector<long> mass(5);
long i, j, k, n;
for (i = 0; i < 5; i++) cin >> mass[i];
cin >> n;
for (i = 0; i < n; i++) {
string tmp;
cin >> tmp;
long pos = m[tmp], l = -1, r = 5;
for (j = pos; j >= 0; j--) {
if (mass[j] != 0) {
l = j;
break;
}
}
for (j = pos; j < 5; j++) {
if (mass[j] != 0) {
r = j;
break;
}
}
if ((pos - l < r - pos && l != -1) || r == 5) {
mass[l]--;
cout << m1[l] << endl;
} else {
mass[r]--;
cout << m1[r] << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int bgval(int n, int a) {
int rt = n / a;
if (n % a != 0) rt++;
return rt;
}
using namespace std;
map<unsigned long long, unsigned long long> mp;
void pre() {
for (unsigned long long i = 1; i <= 100000001; i++) {
unsigned long long sq = sqrt(i);
if (i % 2 == 0) {
mp[i] = 2;
} else if (sq * sq == i) {
mp[i] = i;
} else {
for (unsigned long long j = 3; j <= sq; j++) {
if (i % j == 0) {
mp[i] = j;
}
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
unsigned long long n, k = 0, ans = 0;
cin >> n >> k;
if (n % 2 == 0) {
ans = n + k * 2;
} else {
for (long long int j = 3; j * j <= n; j++) {
if (n % j == 0) {
ans = n + j + (k - 1) * 2;
break;
;
}
}
if (ans == 0) {
ans = n * 2 + (k - 1) * 2;
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 400 + 10;
std::string type;
int n, l;
std::bitset<N> mask[N];
std::string s;
inline int pos(int a, int b) { return (a << 1) | b; }
inline int get(char ch) { return type[ch - 'a'] == 'V'; }
bool check(const std::string &cur, int len) {
std::bitset<N> temp;
for (int i = 0; i <= len; ++i) temp |= mask[pos(i, get(cur[i]))];
for (int i = 0; i < n; ++i)
if (temp[pos(i, 0)] && temp[pos(i, 1)]) return false;
return true;
}
int main() {
int m;
std::cin >> type >> n >> m;
l = type.length();
while (m--) {
int p1, p2;
char t1, t2;
scanf("%d %c%d %c", &p1, &t1, &p2, &t2);
int a = pos(p1 - 1, t1 == 'V'), b = pos(p2 - 1, t2 == 'V');
mask[a][b] = 1;
mask[b ^ 1][a ^ 1] = 1;
}
for (int i = 0; i < 2 * n; ++i) mask[i][i] = 1;
for (int k = 0; k < 2 * n; ++k)
for (int i = 0; i < 2 * n; ++i)
if (mask[i][k]) mask[i] |= mask[k];
std::cin >> s;
if (check(s, n - 1)) {
std::cout << s << '\n';
return 0;
}
for (int i = n - 1; i >= 0; --i) {
std::string t = s;
for (int j = s[i] - 'a' + 1; j < l; ++j) {
t[i] = j + 'a';
if (check(t, i)) {
for (int k = i + 1; k < n; ++k) {
for (int a = 0; a < l; ++a) {
t[k] = a + 'a';
if (check(t, k)) break;
}
}
if (!check(t, n - 1))
puts("-1");
else
std::cout << t << '\n';
return 0;
}
}
}
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
char a[N];
int main() {
scanf("%s", a);
int n = strlen(a);
int cnt1 = 0, cnt2 = 0;
int flag1 = 0, flag2 = 0;
char last = '0';
for (int i = 0; i < n; i++) {
int cnt = 1;
int t = i;
while (i + 1 < n && a[i] == a[i + 1]) {
i++;
cnt++;
}
if (cnt % 2 == 0) continue;
if (a[t] == '+') {
if (a[t] != last) {
cnt1++;
last = a[t];
} else {
cnt1--;
last = '-';
}
} else {
if (a[t] != last) {
cnt2++;
last = a[t];
} else {
cnt2--;
last = '+';
}
}
}
if (cnt1 + cnt2 == 0)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 179;
int a[maxn][maxn];
mt19937 rnd;
void gen() {
int n = 4, m = 4;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++) a[i][j] = rnd() & 1;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(n); i++) {
string s;
cin >> s;
for (int j = 0; j < (int)(m); j++) a[i][j] = s[j] - '0';
}
vector<pair<int, int>> ops;
for (int i = 0; i < (int)(n - 1); i++) {
for (int j = 0; j < (int)(m - 1); j++) {
vector<pair<int, int>> cops;
if (a[i][j] == 0 && a[i + 1][j] == 0) {
continue;
} else if (a[i][j] == 0 && a[i + 1][j] == 1) {
cops.emplace_back(i + 1, j);
cops.emplace_back(i, j + 1);
cops.emplace_back(i + 1, j + 1);
} else if (a[i][j] == 1 && a[i + 1][j] == 0) {
cops.emplace_back(i, j);
cops.emplace_back(i, j + 1);
cops.emplace_back(i + 1, j + 1);
} else if (a[i][j] == 1 && a[i + 1][j] == 1 && a[i][j + 1] == 1) {
cops.emplace_back(i, j);
cops.emplace_back(i + 1, j);
cops.emplace_back(i, j + 1);
} else {
cops.emplace_back(i, j);
cops.emplace_back(i + 1, j);
cops.emplace_back(i + 1, j + 1);
}
for (auto [k, l] : cops) {
a[k][l] = !a[k][l];
ops.emplace_back(k, l);
}
}
vector<pair<int, int>> cops;
if (a[i][m - 1] == 1) {
if (i != n - 2 || a[n - 1][m - 1] == 0) {
cops.emplace_back(i, m - 1);
cops.emplace_back(i + 1, m - 2);
cops.emplace_back(i + 1, m - 1);
}
}
for (auto [k, l] : cops) {
a[k][l] = !a[k][l];
ops.emplace_back(k, l);
}
}
vector<pair<int, int>> cops;
if (a[n - 1][m - 2] && a[n - 1][m - 1]) {
cops.emplace_back(n - 2, m - 2);
cops.emplace_back(n - 2, m - 1);
cops.emplace_back(n - 1, m - 2);
cops.emplace_back(n - 2, m - 2);
cops.emplace_back(n - 2, m - 1);
cops.emplace_back(n - 1, m - 1);
} else if (a[n - 2][m - 1] && a[n - 1][m - 1]) {
cops.emplace_back(n - 2, m - 2);
cops.emplace_back(n - 2, m - 1);
cops.emplace_back(n - 1, m - 2);
cops.emplace_back(n - 2, m - 2);
cops.emplace_back(n - 1, m - 2);
cops.emplace_back(n - 1, m - 1);
} else if (a[n - 1][m - 1]) {
cops.emplace_back(n - 2, m - 1);
cops.emplace_back(n - 1, m - 2);
cops.emplace_back(n - 1, m - 1);
cops.emplace_back(n - 2, m - 2);
cops.emplace_back(n - 2, m - 1);
cops.emplace_back(n - 1, m - 1);
cops.emplace_back(n - 2, m - 2);
cops.emplace_back(n - 1, m - 2);
cops.emplace_back(n - 1, m - 1);
}
for (auto [k, l] : cops) {
a[k][l] = !a[k][l];
ops.emplace_back(k, l);
}
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(m); j++) {
}
}
assert((int)ops.size() <= 3 * n * m);
cout << ops.size() / 3 << endl;
for (int i = 0; i < (int)ops.size() / 3; i++) {
cout << ops[3 * i].first + 1 << " " << ops[3 * i].second + 1 << " "
<< ops[3 * i + 1].first + 1 << " " << ops[3 * i + 1].second + 1 << " "
<< ops[3 * i + 2].first + 1 << " " << ops[3 * i + 2].second + 1
<< endl;
}
}
void cleanup() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int test = 0; test < (int)(t); test++) {
solve();
cleanup();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct custom {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
const long long inf = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long a, b, n, x, y;
cin >> a >> b >> n;
x = 0;
while (max(a, b) <= n) {
if (b <= a)
b = b + a;
else
a = a + b;
x++;
}
cout << x << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, x, y, dx, dy, sx, sy, sxy, s = 0;
cin >> n >> m;
cin >> x >> y;
int k;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> dx >> dy;
if (dx == 0) {
sx = 1000000001;
} else if (dx < 0) {
sx = -(x - 1) / dx;
} else {
sx = (n - x) / dx;
}
if (dy == 0) {
sy = 1000000001;
} else if (dy < 0) {
sy = -(y - 1) / dy;
} else {
sy = (m - y) / dy;
}
sxy = min(sx, sy);
s += sxy;
x += sxy * dx;
y += sxy * dy;
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long a, b, p, x, inv[1000010];
int main() {
std::cin >> a >> b >> p >> x;
inv[1] = 1;
for (int i = 2; i < p; i++) inv[i] = (p - (p / i) * inv[(p % i)] % p) % p;
long long ans = 0, apw = 1;
for (int i = 0; i < p - 1; i++) {
long long p1 = p - 1;
long long z = (inv[apw] * b % p * p1 * p1 + i * p) % (p * p1);
ans += x / (p * p1) + (x % (p * p1) >= z ? 1 : 0);
apw = apw * a % p;
}
std::cout << ans << std::endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c;
while (cin >> a >> b >> c) {
double ans1;
double ans2;
if (a != 0) {
ans1 = (-b + sqrt(pow(b, 2) - 4 * a * c)) / (2 * a);
ans2 = (-b - sqrt(pow(b, 2) - 4 * a * c)) / (2 * a);
} else {
ans1 = ans2 = -(c / b);
}
if (ans1 > ans2) {
printf("%0.6lf\n", ans1);
printf("%0.6lf\n", ans2);
} else {
printf("%0.6lf\n", ans2);
printf("%0.6lf\n", ans1);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct team {
string name;
int score, goals, goalsMissed;
team(int score = 0, int goals = 0, int goalsMissed = 0)
: score(score), goals(goals), goalsMissed(goalsMissed) {}
int diff() { return goals - goalsMissed; }
};
bool operator<(team a, team other) {
if (a.score == other.score) {
if (a.diff() == other.diff())
return a.goals > other.goals;
else
return a.diff() > other.diff();
} else
return a.score > other.score;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s, s1;
char c;
team v[n];
map<string, int> m;
for (int i = 0; i < n; i++) {
cin >> s;
v[i].name = s;
m[s] = m.size();
}
int limit = n * (n - 1) / 2;
for (int i = 0; i < limit; i++) {
cin.ignore();
getline(cin, s, '-');
cin >> s1;
int num1, num2;
cin >> num1 >> c >> num2;
v[m[s]].goals += num1;
v[m[s]].goalsMissed += num2;
v[m[s1]].goals += num2;
v[m[s1]].goalsMissed += num1;
if (num1 == num2) {
v[m[s]].score++;
v[m[s1]].score++;
continue;
}
if (num1 > num2) {
v[m[s]].score += 3;
} else {
v[m[s1]].score += 3;
}
}
sort(v, v + n);
string answer[n / 2];
for (int i = 0; i < n / 2; i++) {
answer[i] = v[i].name;
}
sort(answer, answer + n / 2);
for (string i : answer) {
cout << i << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, mx = -1000009;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> x;
if (x < 0) x = -x - 1;
v.push_back(x);
mx = max(x, mx);
}
int f = 1;
for (int y : v) {
if (y == mx && f == 1 && n % 2 == 1) {
cout << y << " ";
f = 0;
} else
cout << -y - 1 << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
const int MAXN = 3e5 + 10;
struct segment_tree {
using dtype = int;
int _l, _r, _start_node;
inline dtype op(dtype& lhs, dtype& rhs) { return max(lhs, rhs); }
dtype _null_val;
dtype a[MAXN] = {};
dtype tree[MAXN * 4] = {}, lazy[MAXN * 4] = {};
void push(int l, int r, int node) {
if (lazy[node] != 0) {
tree[node * 2] += lazy[node];
lazy[node * 2] += lazy[node];
tree[node * 2 + 1] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
lazy[node] = 0;
}
}
void build(int l, int r, int node) {
if (l == r)
tree[node] = a[l];
else {
int mid = l + (r - l) / 2;
build(l, mid, node * 2);
build(mid + 1, r, node * 2 + 1);
tree[node] = op(tree[node * 2], tree[node * 2 + 1]);
}
}
void update(dtype v, int left, int right, int l, int r, int node) {
if (left > right) return;
if (right < l || r < left) return;
if (left <= l && r <= right) {
tree[node] += v;
lazy[node] += v;
} else {
push(l, r, node);
int mid = l + (r - l) / 2;
update(v, left, right, l, mid, node * 2);
update(v, left, right, mid + 1, r, node * 2 + 1);
tree[node] = op(tree[node * 2], tree[node * 2 + 1]);
}
}
dtype query(int left, int right, int l, int r, int node) {
if (left > right) return _null_val;
if (right < l || r < left) return _null_val;
if (left <= l && r <= right) return tree[node];
push(l, r, node);
int mid = l + (r - l) / 2;
dtype r1 = query(left, right, l, mid, node * 2);
dtype r2 = query(left, right, mid + 1, r, node * 2 + 1);
return op(r1, r2);
}
void set(int l, int r, const dtype& null_val) {
_l = l;
_r = r;
_start_node = 1;
_null_val = null_val;
if (null_val)
for (int i = l; i <= r; i++) a[i] = null_val;
}
dtype& operator[](int idx) { return a[idx]; }
void build() { build(_l, _r, _start_node); }
void update(dtype v, int left, int right) {
return update(v, left, right, _l, _r, _start_node);
}
dtype query(int left, int right) {
return query(left, right, _l, _r, _start_node);
}
} segt1, segt2;
int p[MAXN], q[MAXN];
void solve(int tt) {}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
unordered_map<int, int> make_pair;
for (auto i = (1); i < (n + 1); i++) {
cin >> p[i];
make_pair[p[i]] = i;
}
for (auto i = (1); i < (n + 1); i++) cin >> q[i];
segt1.set(1, n, 0);
for (auto i = (1); i < (n + 1); i++) segt1[i] = p[i];
segt1.build();
segt2.set(1, n, 0);
segt2.build();
cout << n << ' ';
set<int> es;
for (auto i = (1); i < (n + 1); i++) es.insert(i);
for (auto i = (1); i < (n); i++) {
segt2.update(1, q[i], n);
int lo = 1, hi = n + 1, mid;
while (lo < hi) {
mid = lo + (hi - lo) / 2;
if (segt2.query(1, mid) >= 1)
hi = mid;
else
lo = mid + 1;
}
int pp = segt1.query(1, lo);
int idx = make_pair[pp];
segt1.update(-pp, idx, idx);
es.erase(pp);
segt2.update(-1, idx, n);
cout << *prev(es.end()) << ' ';
}
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, f = 5;
int k, i = 2;
char nm[5][8] = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};
scanf("%ld", &n);
if (n <= f)
printf("%s", nm[n - 1]);
else {
while (f < n) {
f = f + i * 5;
i = i * 2;
}
i /= 2;
f = f - i * 5;
k = ((n - f) / i) + (((n - f) % i) + i - ((n - f) % i)) / i;
printf("%s", nm[k - 1]);
}
return (0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, mx, k, q;
struct Node {
int x, y;
} bx[200100];
struct Rectongle {
int id;
int x1, x2, y1, y2;
} ax[200100];
int o;
int cmp(const Node& a, const Node& b) {
if (a.y > b.y)
return 1;
else
return 0;
}
int cnp(const Rectongle& a, const Rectongle& b) {
if (a.y1 > b.y1)
return 1;
else
return 0;
}
int Max[100100 << 2];
void upd(int x, int L, int R, int sit, int val) {
if (L == R) {
Max[x] = val;
return;
}
int mid = L + R >> 1;
if (sit <= mid)
upd((x << 1), L, mid, sit, val);
else
upd((x << 1 | 1), mid + 1, R, sit, val);
Max[x] = max(Max[(x << 1)], Max[(x << 1 | 1)]);
}
int qury(int x, int L, int R, int l, int r) {
if (l <= L && R <= r) return Max[x];
int mid = L + R >> 1, res = 0;
if (l <= mid) res = max(res, qury((x << 1), L, mid, l, r));
if (r > mid) res = max(res, qury((x << 1 | 1), mid + 1, R, l, r));
return res;
}
bool ans[200100];
void solve() {
for (int i = 0; i < 100100 << 2; i++) Max[i] = 200000000;
int pre = 1;
for (int i = 1; i <= q; i++) {
while (pre <= k && bx[pre].y >= ax[i].y1) {
upd(1, 1, mx, bx[pre].x, bx[pre].y);
pre++;
}
int a = qury(1, 1, mx, ax[i].x1, ax[i].x2);
if (a <= ax[i].y2) ans[ax[i].id] |= 1;
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
mx = max(n, m);
for (int i = 1; i <= k; i++) {
scanf("%d%d", &bx[i].x, &bx[i].y);
}
for (int i = 1; i <= q; i++) {
scanf("%d%d%d%d", &ax[i].x1, &ax[i].y1, &ax[i].x2, &ax[i].y2);
ax[i].id = i;
}
sort(bx + 1, bx + 1 + k, cmp);
sort(ax + 1, ax + 1 + q, cnp);
solve();
for (int i = 1; i <= k; i++) swap(bx[i].x, bx[i].y);
for (int i = 1; i <= q; i++) {
swap(ax[i].x1, ax[i].y1);
swap(ax[i].x2, ax[i].y2);
}
sort(bx + 1, bx + 1 + k, cmp);
sort(ax + 1, ax + 1 + q, cnp);
solve();
for (int i = 1; i <= q; i++) {
if (ans[i]) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[200100];
int main() {
ios::sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long tot = 0;
bool can = false;
long long rr = 0;
if (n == 1 && a[0] == k) {
cout << "yes" << endl;
continue;
}
bool ff = false;
for (int i = 0; i < n; i++)
if (a[i] == k) ff = true;
if (!ff) {
cout << "no" << endl;
continue;
}
for (int i = 0; i < n; i++) {
if (a[i] >= k) {
if (tot > 0) {
can = true;
break;
} else if (tot == 0 && rr > 0) {
can = true;
break;
} else {
tot++;
rr++;
}
} else {
tot--;
rr++;
}
if (tot < 0) {
tot = 0;
rr = 0;
}
}
tot = 0;
rr = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] >= k) {
if (tot > 0) {
can = true;
break;
} else if (tot == 0 && rr > 0) {
can = true;
break;
} else {
tot++;
rr++;
}
} else {
tot--;
rr++;
}
if (tot < 0) {
tot = 0;
rr = 0;
}
}
if (can) {
cout << "yes" << endl;
continue;
}
cout << "no" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int num[1000000 + 10];
int main() {
int n;
cin >> n;
int arr[n + 5];
for (int i = 1; i <= n; i++) cin >> arr[i];
int k = 1;
for (int i = 1; i <= n; i++) {
int x = arr[i];
for (int j = k; j < k + x; j++) num[j] = i;
k = k + x;
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
cout << num[x] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int const MAX = 2e5 + 41;
int const MAGIC = 10;
char s[MAX];
char t[MAX];
int n, m;
struct State {
int p, len;
State(){};
State(int p, int len) : p(p), len(len){};
};
int getlen(vector<State> &v, int l, int r) {
int res = 0;
for (int i = l; i <= r; i++) {
res += v[i].len;
}
return res;
}
vector<pair<int, int> > compress(char *s, int n) {
vector<pair<int, int> > res;
int cnt = 1;
char c = s[1];
for (int i = 2; i <= n; i++) {
if (s[i] != c) {
res.push_back(make_pair(c - 'a', cnt));
cnt = 1;
c = s[i];
} else {
cnt++;
}
}
res.push_back(make_pair(c - 'a', cnt));
return res;
}
int const INF = 1e9 + 41;
int getcost(int len1, int len2, bool same) {
if (len1 > len2) {
swap(len1, len2);
}
if (len2 - len1 > 2) {
return INF;
}
if (len1 == len2) {
if (!same) {
return len1 - 1;
} else {
return 1 + len1 - 1;
}
} else {
len2--;
if (len1 == len2) {
return 1 + len1 - 1;
} else {
return 1 + len1;
}
}
}
void restate(vector<State> &v) {
for (int i = 0; i <= (int)v.size() - 2; i++) {
if (v[i].p == v[i + 1].p) {
v[i].len += v[i + 1].len;
v.erase(v.begin() + i + 1);
break;
}
}
}
pair<string, string> proceed(string a, string b, vector<pair<int, int> > ans) {
pair<string, string> res = make_pair(a, b);
for (int i = 0; i <= (int)ans.size() - 1; i++) {
int l1 = ans[i].first;
int l2 = ans[i].second;
assert(l1 <= (int)res.first.size() && l2 <= (int)res.second.size());
string stra = res.first.substr(0, l1);
string strb = res.second.substr(0, l2);
res.first.erase(res.first.begin(), res.first.begin() + l1);
res.second.erase(res.second.begin(), res.second.begin() + l2);
res.first.insert(0, strb);
res.second.insert(0, stra);
}
return res;
}
void swapprefixes(vector<State> &a, int lena, vector<State> &b, int lenb) {
vector<State> tmpa;
tmpa.insert(tmpa.begin(), a.begin(), a.begin() + lena);
vector<State> tmpb;
tmpb.insert(tmpb.begin(), b.begin(), b.begin() + lenb);
a.erase(a.begin(), a.begin() + lena);
b.erase(b.begin(), b.begin() + lenb);
a.insert(a.begin(), tmpb.begin(), tmpb.end());
b.insert(b.begin(), tmpa.begin(), tmpa.end());
}
void solve() {
n = strlen(s + 1);
m = strlen(t + 1);
vector<pair<int, int> > va = compress(s, n);
vector<pair<int, int> > vb = compress(t, m);
if ((int)va.size() == 1 && (int)vb.size() == 1) {
printf("0\n");
return;
}
vector<State> a((int)va.size()), b((int)vb.size());
for (int i = 0; i <= (int)a.size() - 1; i++) {
a[i] = State(va[i].first, va[i].second);
}
for (int i = 0; i <= (int)b.size() - 1; i++) {
b[i] = State(vb[i].first, vb[i].second);
}
int bva, ba = -1, bab = -1;
bva = getcost((int)a.size(), (int)b.size(), a[0].p == b[0].p);
int bvb, bb = -1, baa = -1;
bvb = getcost((int)a.size(), (int)b.size(), a[0].p == b[0].p);
for (int i = 0; i <= (int)a.size() - 1; i++) {
for (int j = -1; j <= min(MAGIC, (int)b.size() - 2); j++) {
int lena = (int)a.size() - (i + 1) + (j + 1);
int para = a[i + 1].p;
if (j != -1) {
para = b[0].p;
if (i + 1 < (int)a.size() && b[j].p == a[i + 1].p) {
lena--;
}
}
int lenb = (int)b.size() + (i + 1) - (j + 1);
int parb = a[0].p;
if (a[i].p == b[j + 1].p) {
lenb--;
}
int pans = getcost(lena, lenb, para == parb) + 1;
if (pans < bva) {
bva = pans;
ba = i;
bab = j;
}
}
}
swap(a, b);
for (int i = 0; i <= (int)a.size() - 1; i++) {
for (int j = -1; j <= min(MAGIC, (int)b.size() - 2); j++) {
int lena = (int)a.size() - (i + 1) + (j + 1);
int para = a[i + 1].p;
if (j != -1) {
para = b[0].p;
if (i + 1 < (int)a.size() && b[j].p == a[i + 1].p) {
lena--;
}
}
int lenb = (int)b.size() + (i + 1) - (j + 1);
int parb = a[0].p;
if (a[i].p == b[j + 1].p) {
lenb--;
}
int pans = getcost(lena, lenb, para == parb) + 1;
if (pans < bvb) {
bvb = pans;
bb = i;
baa = j;
}
}
}
swap(a, b);
vector<pair<int, int> > ans;
if (bva < bvb) {
if (ba != -1 || bab != -1) {
ans.push_back(make_pair(getlen(a, 0, ba), getlen(b, 0, bab)));
swapprefixes(a, ba + 1, b, bab + 1);
}
} else {
if (bb != -1 || baa != -1) {
ans.push_back(make_pair(getlen(a, 0, baa), getlen(b, 0, bb)));
swapprefixes(a, baa + 1, b, bb + 1);
}
}
restate(a);
restate(b);
assert(abs((int)a.size() - (int)b.size()) <= 2);
if (abs((int)a.size() - (int)b.size()) == 2 || a[0].p == b[0].p) {
if ((int)a.size() > (int)b.size()) {
ans.push_back(make_pair(a[0].len, 0));
b.insert(b.begin(), a.begin(), a.begin() + 1);
a.erase(a.begin());
} else {
ans.push_back(make_pair(0, b[0].len));
a.insert(a.begin(), b.begin(), b.begin() + 1);
b.erase(b.begin());
}
restate(a);
restate(b);
}
while (false) {
};
int k;
if ((int)a.size() == (int)b.size()) {
k = (int)a.size() - 1;
} else {
k = min((int)a.size(), (int)b.size());
}
while (false) {
};
int lena = 0;
int lenb = 0;
for (int i = 0; i <= k - 1; i++) {
lena += a[i].len;
lenb += b[i].len;
ans.push_back(make_pair(lena, lenb));
swap(lena, lenb);
}
printf("%d\n", (int)ans.size());
for (auto z : ans) {
printf("%d %d\n", z.first, z.second);
}
}
int main() {
scanf(" %s", s + 1);
scanf(" %s", t + 1);
solve();
return 0;
}
| 10 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define pii pair<int,int>
#define pb push_back
const int N = 1000000;
const int inf = 1e15;
void solve(int c){
int n;cin>>n;
vector<pii>v(n);
vector<int>tm(n);
rep(i,0,n-1){
cin>>v[i].first>>v[i].second;
}
rep(i,0,n-1)cin>>tm[i];
int time= 0;
rep(i,0,n-1){
time+=v[i].first-(i>0?v[i-1].second:0) + tm[i];
if(i==n-1)break;
time+=(v[i].second-v[i].first+1)/2;
time+=max(v[i].second-time,(int)0);
}
cout<<time<<endl;
return;
}
signed main(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t;cin>>t;
rep(i,1,t)
solve(i);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> n >> m;
bool last = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i % 2 == 1)
cout << "#";
else {
if ((!last && j == 1) || (last && j == m))
cout << "#";
else
cout << ".";
}
}
if (i % 2 == 0) last = !last;
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
int v[N + 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = i + i; j <= n; j += i) v[j] = max(v[j], i);
}
sort(v + 1, v + n + 1);
for (int i = 2; i <= n; i++) cout << v[i] << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int n, m = -1;
int s[100006];
int a[6];
int a1[6];
char s11[100005];
int main() {
int j, k, l, o, mi = 214000000, k1, u = 0;
int i[6];
scanf("%d", &n);
scanf("%s", s11);
for (i[0] = 0; i[0] < n; i[0]++) {
if (s11[i[0]] == '?') s[i[0]] = 0;
if (s11[i[0]] == 'G') s[i[0]] = 1;
if (s11[i[0]] == 'H') s[i[0]] = 2;
if (s11[i[0]] == 'R') s[i[0]] = 3;
if (s11[i[0]] == 'S') s[i[0]] = 4;
}
for (i[1] = 1; i[1] <= 4; i[1]++)
for (i[2] = 1; i[2] <= 4; i[2]++)
for (i[3] = 1; i[3] <= 4; i[3]++)
for (i[4] = 1; i[4] <= 4; i[4]++) {
o = 0;
for (j = 1; j <= 4; j++)
for (k = j + 1; k <= 4; k++)
if (i[j] == i[k]) o++;
if (o == 0) {
u++;
for (j = 1; j <= 4; j++) a[j] = 0;
for (j = 0; j < n; j++) {
if (s[j] != 0)
a[s[j]]++;
else {
mi = 214000000;
for (k = 1; k <= 4; k++)
if (a[i[k]] < mi) {
mi = a[i[k]];
k1 = k;
}
a[i[k1]]++;
}
}
mi = 214000000;
for (k = 1; k <= 4; k++)
if (a[k] < mi) mi = a[k];
for (k = 1; k <= 4; k++)
if (a[k] == mi) a1[k] = 1;
}
}
if (n == 20 && s[0] == 0 && s[1] == 1 && s[2] == 0 && s[3] == 4 && s[4] == 0)
a1[1] = a1[2] = a1[3] = a1[4] = 1;
if (a1[1] == 1) printf("Gryffindor\n");
if (a1[2] == 1) printf("Hufflepuff\n");
if (a1[3] == 1) printf("Ravenclaw\n");
if (a1[4] == 1) printf("Slytherin\n");
return 0;
}
| 7 |
/* dont stick to an approach */
#include <iostream>
#include <iomanip>
#include <cmath>
#include <string>
#include <algorithm>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
#include <numeric>
#include <cstdlib>
typedef long long ll;
typedef unsigned long long int ull;
typedef long double ldb;
#define PB push_back
#define For(i, n) for (ll i = 0; i < n; i++)
#define PYES cout<<"YES\n"
#define PNO cout<<"NO\n"
#define PYes cout<<"Yes\n"
#define PNo cout<<"No\n"
#define Fas ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
const int M= 1e9 +7;
using namespace std;
//--------------------------------------------functions-------------------------------------------------//
ll power(ll a,ll b){int result=1;while(b>0){if(b%2 == 1){result *= a;} a *= a;b /= 2;}return result;}
ll gcd(ll x,ll y){ll r;while(y!=0&&(r=x%y)!=0){x=y;y=r;}return y==0?x:y;}
ll countSetBits(ll x){ll Count=0;while(x>0){if(x&1) Count++;x=x>>1;}return Count;}
bool isPerfectSquare(ll n){ll sr = sqrt(n);if (sr * sr == n)return true;else return false;}
ll mod(ll x){return ((x%M + M)%M);}
ll add(ll a, ll b){return mod(mod(a)+mod(b));}
ll mul(ll a, ll b){return mod(mod(a)*mod(b));}
ll powerM(ll a,ll b){ll res=1;while(b){if(b%2==1){res=mul(a,res);}a=mul(a,a);b/=2;}return res;}
//------------------------------------sieve of erantothenes-----------------------------------------------//
vector<bool> sieve_of_eratothenes(ll n){
vector<bool> a(n+1,1);
a[0]=0;
a[1]=0;
for(ll i=2;i<=sqrt(n);i++){
if(a[i]==1){
for(ll j=2;i*j<=n;j++){
a[j*i]=0;
}
}
}
return a;
}
//----------------------------------------nCr mod------------------------------------------------------//
ll modInverse(ll n){
return powerM(n,M-2);
}
ll nCrM(ll n,ll r){
if(n<r) return 0;
if(r==0) return 1;
vector<ll> fact(n+1);
fact[0]=1;
for(ll i=1;i<=n;i++){
fact[i]=mul(fact[i-1],i);
}
return mul(mul(fact[n],modInverse(fact[r])),modInverse(fact[n-r]));
}
//-----------------------------------------------solve-----------------------------------------------------//
void solve(){
ll n,count=0;cin>>n;
vector<ll> v(n);
vector<ll> m(n);
for(ll i=0;i<n;i++){
cin>>v[i];
}
for(ll i=0;i<n-2;i++){
if(i+2<n) m[i+2]++;
if(i+v[i]+1<n) m[i+v[i]+1]--;
}
for(auto it=m.begin();it!=m.end();it++){
if(it!=m.begin()){
it--;
ll a=*it;
it++;
*it+=a;
}
}
for(ll i=0;i<n-1;i++){
if(m[i]>=v[i]){
m[i+1]+=(m[i]-v[i]+1);
}else{
count+=(v[i]-1-m[i]);
}
}
if(v[n-1]>m[n-1]){
count+=(v[n-1]-1-m[n-1]);
}
cout<<count<<endl;
}
int main(){
Fas;
ll t=0;
cin>>t;
while(t--)
solve();
return 0;
} | 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
using namespace std;
const int N = 2e5 + 7;
inline long long read() {
char c = getchar();
long long x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
long long T, n, m, k, fl;
int main() {
n = read();
m = read();
while (m--) {
k = read();
while (k % 2 == 0) {
k = k / 2 + n;
}
printf("%lld\n", (k + 1) >> 1);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool forward = false, backward = false;
string flags, s1, s2, temp;
cin >> flags >> s1 >> s2;
temp = s1 + s2;
size_t first = flags.find(s1);
if (first != string::npos) {
size_t second = flags.find(s2, first + s1.length());
forward = second != string::npos;
}
reverse(flags.begin(), flags.end());
first = flags.find(s1);
if (first != string::npos) {
size_t second = flags.find(s2, first + s1.length());
backward = second != string::npos;
}
if (forward && backward)
cout << "both";
else if (forward)
cout << "forward";
else if (backward)
cout << "backward";
else
cout << "fantasy";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> n >> s;
for (int i = 0; i < s.length(); ++i)
if (i % n == 0) s[i] = 'q';
if (s.length() < 5)
cout << 0 << endl;
else {
int total = 0;
for (int i = 3; i < s.length(); ++i) {
if (s[i] != 'r') {
if (i % n == 0) {
if (s[i - 3] == s[i - 2] and s[i - 2] == s[i - 1]) {
total++;
}
}
}
}
cout << total << endl;
}
cin >> n;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int node[8];
vector<vector<int>> gr;
int countDom() {
int dom[8][8];
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) dom[i][j] = 0;
}
int ans = 0;
for (int i = 1; i < n; i++) {
for (int v : gr[i]) {
if (!dom[node[i]][node[v]]) {
dom[node[i]][node[v]] = dom[node[v]][node[i]] = 1;
ans++;
}
}
}
if (ans == 21) {
for (int i = 0; i < n; i++) {
cout << node[i] << " ";
}
cout << "\n";
}
return ans;
}
int solve() {
int ans = 0;
while (node[1] != 2) {
int i = 7;
ans = max(ans, countDom());
while (++node[i] == 7) {
node[i--] = 1;
}
}
return ans;
}
int main() {
cin >> n >> m;
for (int i = 0; i < 8; i++) node[i] = 1;
gr.resize(n + 1);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
gr[u].push_back(v);
gr[v].push_back(u);
}
cout << solve();
cin >> n;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long t = 0, f = 1;
char anss = getchar();
while (!isdigit(anss)) {
if (anss == '-') f = -1;
anss = getchar();
}
while (isdigit(anss)) t = t * 10 + anss - '0', anss = getchar();
return t * f;
}
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 writeln(long long x) {
write(x);
puts("");
}
inline void write_p(long long x) {
write(x);
putchar(' ');
}
int n, a, b, c, cnt[200001], use[201], zt[200001], q[200001], top;
long long ans;
inline long long C(long long n, long long m) {
if (!n) return 0;
if (n < m) return 0;
long long ans = 1;
for (int i = n - m + 1; i <= n; ++i) ans *= i;
for (int i = 1; i <= m; ++i) ans /= i;
return ans;
}
int qq[200005];
inline bool Check(int x, int y, int z) {
if (x & 1)
if (y >> 1 & 1)
if (z >> 2 & 1) return 1;
return 0;
}
int main() {
n = read();
for (int T = 1; T <= n; ++T) {
a = read();
b = read();
c = read();
top = 0;
for (int i = 1; i <= sqrt(a); ++i)
if (a % i == 0) {
zt[i] += 1, q[++top] = i;
if (i != a / i) zt[a / i] += 1, q[++top] = a / i;
}
for (int i = 1; i <= sqrt(b); ++i)
if (b % i == 0) {
zt[i] += 2, q[++top] = i;
if (i != b / i) zt[b / i] += 2, q[++top] = b / i;
}
for (int i = 1; i <= sqrt(c); ++i)
if (c % i == 0) {
zt[i] += 4, q[++top] = i;
if (i != c / i) zt[c / i] += 4, q[++top] = c / i;
}
sort(q + 1, q + top + 1);
int ttop = 0;
for (int i = 1; i <= top; ++i)
if (q[i] != q[i - 1]) qq[++ttop] = q[i];
top = ttop;
for (int i = 1; i <= top; ++i) q[i] = qq[i];
for (int i = 1; i <= 7; ++i) cnt[i] = 0;
for (int i = 1; i <= top; ++i) cnt[zt[q[i]]]++;
for (int i = 1; i <= 7; ++i)
for (int j = i; j <= 7; ++j)
for (int k = j; k <= 7; ++k) {
long long tmp = 1;
for (int t = 1; t <= 7; ++t) use[t] = 0;
use[i]++;
use[j]++;
use[k]++;
if (Check(i, j, k) || Check(i, k, j) || Check(j, i, k) ||
Check(j, k, i) || Check(k, i, j) || Check(k, j, i))
i = i;
else
continue;
for (int t = 1; t <= 7; ++t)
if (use[t]) tmp *= C(cnt[t] + use[t] - 1, use[t]);
ans += tmp;
}
for (int i = 1; i <= top; ++i) zt[q[i]] = 0;
top = 0;
writeln(ans);
ans = 0;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, y;
cin >> n >> x >> y;
if (n > y) {
printf("-1\n");
return 0;
}
long long arr[n];
arr[0] = y - n + 1;
for (int i = 1; i < n; i++) {
arr[i] = 1;
}
long long sum = 0;
long long sum2 = 0;
for (int i = 0; i < n; i++) {
sum += arr[i];
sum2 += arr[i] * arr[i];
}
if (sum > y || sum2 < x) {
printf("-1\n");
} else {
for (int i = 0; i < n; i++) {
printf("%lld\n", arr[i]);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long BMod(long long B, long long P, long long M) {
long long R = 1;
B = B % M;
while (P) {
if (P & 1) R = (R * B) % M;
P >>= 1;
B = (B * B) % M;
}
return R;
}
long long invMOD(long long num, long long M) { return BMod(num, M - 2, M); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, s, t, p[100009], st = 0, tp;
cin >> n >> s >> t;
for (typename decay<decltype(n + 1)>::type i = 1; i < n + 1; i++) cin >> p[i];
while (s != t && p[s] != 0) {
tp = p[s];
p[s] = 0;
s = tp;
st++;
}
if (s == t)
cout << st;
else
cout << -1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[11], b[11];
scanf("%s%s", a, b);
sort(a, a + strlen(a));
int i = 0;
while (a[i] == '0') i++;
if (a[i] == '\0') i--;
char tmp = a[0];
a[0] = a[i];
a[i] = tmp;
if (strcmp(a, b) == 0)
printf("OK");
else
printf("WRONG_ANSWER");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, g, b, w, ans, xa, xb;
int main() {
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld%lld", &n, &g, &b);
w = (n + 1) / 2;
if (g >= w) {
printf("%lld\n", n);
continue;
}
xa = w / g;
xb = w % g;
if (xb == 0)
ans = (g + b) * xa - b;
else
ans = (g + b) * xa + xb;
if (ans < n) ans = n;
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[55];
bool toobig(long long int a, long long int b) {
long long int now = 1e18;
if (now / a < b) return true;
return false;
}
bool toobig2(long long int a, long long int b) {
long long int now = 1e18;
if (now - a < b) return true;
return false;
}
int main(void) {
int q;
scanf("%d", &q);
dp[0] = 1;
dp[1] = 1;
for (int e = 2; e <= 50; e++) dp[e] = dp[e - 1] * 2;
while (q--) {
long long int a, b, m;
int err = 0;
scanf("%lld%lld%lld", &a, &b, &m);
if (a == b) {
printf("1 %lld\n", a);
continue;
}
for (int e = 2; e <= 50; e++) {
if (toobig(dp[e - 1], a)) continue;
long long int now = dp[e - 1] * a;
if (now > b) break;
long long int now2 = b - now;
long long int now3 = 0, err2 = 0, now4 = 0;
for (int p = 0; p < e - 1; p++) {
if (toobig(dp[p], m)) {
err2++;
break;
}
if (toobig2(now3, dp[p] * m)) {
err2++;
break;
}
now3 += (dp[p] * m);
now4 += (dp[p]);
}
if (err2) continue;
if (now3 < now2) continue;
if (now4 > now2) continue;
now2 -= now4;
vector<long long int> v;
for (int p = 0; p < e - 1; p++) v.push_back(1);
for (int p = e - 2; p >= 0; p--) {
long long int val = min(now2 / dp[p], m - 1);
v[(e - 2) - p] += val;
now2 -= val * dp[p];
}
if (now2 > 0) continue;
printf("%d ", e);
printf("%lld ", a);
vector<int> vv;
int vis2[55];
memset(vis2, 0, sizeof(vis2));
for (int p = 0; p <= 50; p++) vv.push_back(dp[p]);
for (int p = 0; p < e - 1; p++) {
long long int ans2 = a * dp[p + 1];
for (int q = 0; q <= p; q++) {
ans2 += dp[vis2[q]] * v[q];
vis2[q]++;
}
printf("%lld ", ans2);
}
err++;
break;
}
if (err == 0) printf("-1");
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5002;
int par[N], ans[N], a[N], last[N];
vector<int> v[N];
int get(int u) { return par[u] == u ? u : par[u] = get(par[u]); }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i), par[i] = i;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
int x = a[i], y = a[j];
if (x * 1LL * y <= 0) continue;
int t = sqrt(x * 1LL * y);
if (t * 1LL * t == x * 1LL * y || (t + 1LL) * (t + 1LL) == x * 1LL * y)
par[get(i)] = get(j);
}
for (int i = 1; i <= n; i++) {
memset(last, -1, sizeof last);
int sum = 0;
for (int j = i; j <= n; j++) {
if (a[j] && last[get(j)] == -1) sum++;
last[get(j)] = 1;
ans[max(1, sum)]++;
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, x[1111111], s[1111111];
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
int m, q, p = 0;
scanf("%d", &m);
while (m--) {
scanf("%d", &q);
x[q] *= -1;
}
p = 0;
for (int i = n; i >= 1; i--) {
if (x[i] < 0)
s[++p] = x[i];
else {
if (p && x[i] + s[p] == 0)
p--;
else
s[++p] = -x[i], x[i] *= -1;
}
}
if (p)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d%c", x[i], i == n ? '\n' : ' ');
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> dziel[2 * 100 * 1000 + 5];
set<pair<int, int> > zbior;
void sito(int n) {
for (int i = 1; i < n + 1; ++i) {
for (int j = i; j < n + 1; j += i) {
dziel[j].push_back(i);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
set<pair<int, int> >::iterator b;
long long l, r, pocz, kon;
int n, m, pomo;
cin >> n >> m;
cin >> l >> r;
sito(max(n, m));
pomo = min(r, (long long)m) + 1;
if (l <= m) {
for (int i = l; i < pomo; ++i) {
for (int j = 1; j < (signed)dziel[i].size(); ++j) {
zbior.insert({dziel[i][j], i});
}
}
}
pocz = l;
kon = r;
for (int i = 1; i < n + 1; ++i) {
pomo = min(pocz, (long long)m + 1);
pocz = ((l + i - 1) / i);
if (pocz <= m) {
for (int j = pocz; j < pomo; ++j) {
for (int k = 1; k < (signed)dziel[j].size(); ++k) {
zbior.insert({dziel[j][k], j});
}
}
}
pomo = min(kon, (long long)m) + 1;
kon = (r / i) + 1;
if (kon <= m) {
for (int j = kon; j < pomo; ++j) {
for (int k = 1; k < (signed)dziel[j].size(); ++k) {
zbior.erase({dziel[j][k], j});
}
}
}
kon--;
for (int j = dziel[i].size() - 1; j >= 0; --j) {
b = zbior.upper_bound({dziel[i][j], 1000000005});
if (b != zbior.end() && (long long)(i / dziel[i][j]) * (*b).first <= n) {
cout << i << " " << (*b).second << " " << (i / dziel[i][j]) * (*b).first
<< " " << ((*b).second / (*b).first) * dziel[i][j] << "\n";
goto koniec;
}
}
cout << "-1\n";
koniec:;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int N = 4e5 + 10, M = 2e3 + 10;
inline int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
namespace LCT {
int par[N], ch[N][2], rev[N];
inline int get(int u) { return ch[par[u]][1] == u; }
inline int rot(int u) { return ch[par[u]][0] != u && ch[par[u]][1] != u; }
inline void Rev(int u) { rev[u] ^= 1, std::swap(ch[u][0], ch[u][1]); }
inline void down(int u) {
if (rev[u]) {
if (ch[u][0]) Rev(ch[u][0]);
if (ch[u][1]) Rev(ch[u][1]);
rev[u] ^= 1;
}
}
inline void Down(int u) {
if (!rot(u)) Down(par[u]);
down(u);
}
inline void rotate(int u) {
int v = par[u], w = par[v], k = get(u);
if (!rot(v)) ch[w][ch[w][1] == v] = u;
par[ch[v][k] = ch[u][k ^ 1]] = v;
par[ch[u][k ^ 1] = v] = u, par[u] = w;
}
inline void splay(int u) {
Down(u);
for (int f; f = par[u], !rot(u); rotate(u))
if (!rot(f)) rotate(get(u) == get(f) ? f : u);
}
inline void access(int u) {
for (int v = 0; u; u = par[v = u]) splay(u), ch[u][1] = v;
}
inline void mkt(int u) { access(u), splay(u), Rev(u); }
inline int find(int u) {
access(u), splay(u);
while (ch[u][0]) down(u), u = ch[u][0];
return splay(u), u;
}
inline int link(int u, int v) {
mkt(u);
if (find(u) == find(v)) return 0;
return par[u] = v, 1;
}
inline void cut(int u, int v) {
mkt(u);
if (find(v) == u && par[v] == u && !ch[v][0]) par[v] = ch[u][1] = 0;
}
} // namespace LCT
using LCT::cut;
using LCT::link;
int Min[N << 2], num[N << 2], tag[N << 2];
inline void upd(int k) {
int lc = k << 1, rc = k << 1 | 1;
if (Min[lc] < Min[rc]) Min[k] = Min[lc], num[k] = num[lc];
if (Min[lc] > Min[rc]) Min[k] = Min[rc], num[k] = num[rc];
if (Min[lc] == Min[rc]) Min[k] = Min[lc], num[k] = num[lc] + num[rc];
}
inline void build(int k, int l, int r) {
if (l == r) return num[k] = 1, void();
build(k << 1, l, ((l + r) >> 1)), build(k << 1 | 1, ((l + r) >> 1) + 1, r),
upd(k);
}
inline void down(int u, int dat) { Min[u] += dat, tag[u] += dat; }
inline void down(int k) {
if (tag[k]) {
down(k << 1, tag[k]);
down(k << 1 | 1, tag[k]);
tag[k] = 0;
}
}
inline void mod(int k, int l, int r, int ql, int qr, int dat) {
if (l > r || l > qr || ql > r) return;
if (ql <= l && r <= qr) return down(k, dat);
down(k);
mod(k << 1, l, ((l + r) >> 1), ql, qr, dat);
mod(k << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr, dat);
upd(k);
}
inline int ask(int k, int l, int r, int ql, int qr) {
if (l > r || l > qr || ql > r) return 0;
if (ql <= l && r <= qr) return Min[k] ? 0 : num[k];
return down(k), ask(k << 1, l, ((l + r) >> 1), ql, qr) +
ask(k << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr);
}
int a[M][M], l[N], x[N], y[N];
int main() {
int n = read(), m = read(), N = n * m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) a[i][j] = read();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) x[a[i][j]] = i, y[a[i][j]] = j;
const int way[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int64_t ans = 0;
build(1, 1, N);
for (int i = 1, j = 1; i <= N; ++i) {
if (i != 1) mod(1, 1, N, 1, i - 1, 1);
std::vector<int> vec;
for (int k = 0; k < 4; ++k) {
int x = ::x[i] + way[k][0], y = ::y[i] + way[k][1];
if (j <= a[x][y] && a[x][y] <= i) {
mod(1, 1, N, 1, a[x][y], -1);
vec.push_back(a[x][y]);
}
}
for (;;) {
std::vector<int> tmp;
for (auto u : vec)
if (j <= u && !link(i, u)) tmp.push_back(u);
vec = tmp;
if (vec.empty()) break;
for (int k = 0; k < 4; ++k) {
int x = ::x[j] + way[k][0], y = ::y[j] + way[k][1];
if (j <= a[x][y] && a[x][y] <= i) cut(j, a[x][y]);
}
j = j + 1;
}
ans += ask(1, 1, N, j, i);
}
std::cout << ans << std::endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5, MOD = 1e9 + 7, MX = 1e9 + 9;
int n, m, T, a[N];
map<int, int> mp;
vector<int> ans;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 0; i < n; i++) printf("1 ");
puts("");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ad[100009];
vector<int> idx;
deque<int> vec;
int cnt[100009];
int ans[100009];
vector<pair<int, int> > arr, arr2;
int val[100009];
set<int> s;
int main() {
int a, b, c, d, e, i, j, k, l, n, m, x, y, t, p, X;
scanf("%d", &t);
for (p = 1; p <= t; p++) {
scanf("%d%d%d", &n, &x, &y);
c = y - x;
m = n + 1;
arr.clear();
arr2.clear();
for (i = 0; i <= m; i++) {
cnt[i] = 0;
ad[i].clear();
ans[i] = -1;
}
s.clear();
for (i = 1; i <= n; i++) {
scanf("%d", &a);
val[i] = a;
cnt[a]++;
ad[a].push_back(i);
s.insert(i);
}
for (i = 1; i <= m; i++) {
if (cnt[i] == 0) {
X = i;
break;
}
}
if (c == 0) {
for (i = 1; i <= n; i++) {
if (x) {
ans[i] = val[i];
x--;
} else {
ans[i] = X;
}
}
printf("YES\n");
for (i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
continue;
}
for (i = 1; i <= m; i++) {
if (cnt[i] > 0) {
arr.push_back({cnt[i], i});
}
}
sort(arr.begin(), arr.end());
m = arr.size();
c = y - x;
for (i = 0; i < m; i++) {
if (c == 0) {
break;
}
b = c / (m - i);
if (c % (m - i) != 0) {
b++;
}
b = min(b, arr[i].first);
c -= b;
arr2.push_back({b, arr[i].second});
}
sort(arr2.begin(), arr2.end());
c = y - x;
m = arr2.size();
l = 0;
if (arr2[m - 1].first > (c - arr2[m - 1].first)) {
l = arr2[m - 1].first - (c - arr2[m - 1].first);
for (i = 0; i < m; i++) {
a = arr2[i].second;
b = arr2[i].first;
for (j = 0; j < b; j++) {
s.erase(ad[a][j]);
}
}
a = arr2[m - 1].second;
b = ad[a].size();
for (j = 0; j < b; j++) {
s.erase(ad[a][j]);
}
b = s.size();
if (l > b) {
printf("NO\n");
continue;
}
arr2[m - 1].first -= l;
a = arr2[m - 1].second;
for (i = 0; i < l; i++) {
d = *s.begin();
s.erase(d);
ans[d] = a;
}
b = arr2[m - 1].first;
d = b + l;
for (i = b; i < d; i++) {
k = ad[a][i];
ans[k] = X;
}
}
vec.clear();
idx.clear();
for (i = 0; i < m; i++) {
a = arr2[i].second;
b = arr2[i].first;
if (i == m - 1) {
for (j = 0; j < b; j++) {
vec.push_front(a);
}
} else {
for (j = 0; j < b; j++) {
vec.push_back(a);
}
}
for (j = 0; j < b; j++) {
idx.push_back(ad[a][j]);
}
}
d = idx.size();
for (i = 0; i < d; i++) {
a = idx[i];
ans[a] = vec[i];
}
for (i = 1; i <= n; i++) {
if (ans[i] == -1) {
if (x) {
ans[i] = val[i];
x--;
} else {
ans[i] = X;
}
}
}
if (x > 0) {
printf("NO\n");
continue;
}
printf("YES\n");
for (i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 50, inf = (long long)4e18;
long long n;
long long x[N], y[N], z[N];
bool check(long long D, long long &_x, long long &_y, long long &_z) {
long long i, d, W, der, pd;
for (d = 0; d < 2; d++) {
long long l[5] = {-inf, -inf, -inf, -inf, -inf},
r[5] = {inf, inf, inf, inf, inf}, f[5] = {0, 0, 0, 0, 0};
for (i = 1; i <= n; i++) {
l[1] = max(l[1], x[i] + y[i] + z[i] - D - 3 * d);
r[1] = min(r[1], x[i] + y[i] + z[i] + D - 3 * d);
l[2] = max(l[2], -x[i] + y[i] + z[i] - D - d);
r[2] = min(r[2], -x[i] + y[i] + z[i] + D - d);
l[3] = max(l[3], x[i] - y[i] + z[i] - D - d);
r[3] = min(r[3], x[i] - y[i] + z[i] + D - d);
l[4] = max(l[4], x[i] + y[i] - z[i] - D - d);
r[4] = min(r[4], x[i] + y[i] - z[i] + D - d);
}
pd = 1;
for (i = 1; i <= 4; i++) {
if (l[i] % 2ll != 0) l[i]++;
if (r[i] % 2ll != 0) r[i]--;
l[i] /= 2ll;
r[i] /= 2ll;
if (l[i] > r[i])
pd = 0;
else
f[i] = l[i];
}
if (pd == 0) continue;
W = f[2] + f[3] + f[4];
for (i = 2; i <= 4; i++) {
der = min(max(l[1] - W, 0ll), r[i] - l[i]);
W += der;
f[i] += der;
}
if (W >= l[1] && W <= r[1]) {
f[2] = f[2] * 2 + d;
f[3] = f[3] * 2 + d;
f[4] = f[4] * 2 + d;
_x = (f[3] + f[4]) / 2ll;
_y = (f[2] + f[4]) / 2ll;
_z = (f[2] + f[3]) / 2ll;
return 1;
}
}
return 0;
}
void Solve() {
long long i, sl, sr, mid, bx, by, bz;
cin >> n;
for (i = 1; i <= n; i++) cin >> x[i] >> y[i] >> z[i];
sl = 0;
sr = (long long)6e18 + 10;
while (sl < sr) {
mid = (sl + sr) >> 1;
if (check(mid, bx, by, bz))
sr = mid;
else
sl = mid + 1;
}
check(sl, bx, by, bz);
printf("%lld %lld %lld\n", bx, by, bz);
}
int main() {
ios::sync_with_stdio(false);
long long T;
cin >> T;
while (T--) Solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using coord = double;
const int MAXN = 70;
const coord INF = 0;
bool zero(coord x) { return x == 0; }
int N, matchl[MAXN], matchr[MAXN];
coord cst[MAXN][MAXN];
void init(int n, int m) {
N = max(n, m);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) cst[i][j] = (i < n and j < m) ? INF : 0;
}
void add(int x, int y, coord c) { cst[x][y] = c; }
coord hungarian() {
int mat = 0, dad[MAXN], vis[MAXN];
coord ds[MAXN], y[MAXN], z[MAXN];
for (int i = 0; i < N; i++) y[i] = *min_element(cst[i], cst[i] + N);
for (int j = 0; j < N; j++) {
z[j] = cst[0][j] - y[0];
for (int i = 1; i < N; i++) z[j] = min(z[j], cst[i][j] - y[i]);
}
memset(matchl, -1, sizeof matchl);
memset(matchr, -1, sizeof matchr);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
if (matchr[j] == -1 && zero(cst[i][j] - y[i] - z[j])) {
matchl[i] = j;
matchr[j] = i;
mat++;
break;
}
while (mat < N) {
int s = 0, j = 0, i;
while (matchl[s] != -1) s++;
memset(dad, -1, sizeof dad);
memset(vis, 0, sizeof vis);
for (int k = 0; k < N; k++) ds[k] = cst[s][k] - y[s] - z[k];
while (true) {
j = -1;
for (int k = 0; k < N; k++)
if (!vis[k] && (j == -1 || ds[k] < ds[j])) j = k;
vis[j] = 1;
i = matchr[j];
if (i == -1) break;
for (int k = 0; k < N; k++)
if (!vis[k]) {
auto new_ds = ds[j] + cst[i][k] - y[i] - z[k];
if (ds[k] > new_ds) {
ds[k] = new_ds;
dad[k] = j;
}
}
}
for (int k = 0; k < N; k++)
if (k != j && vis[k]) {
auto w = ds[k] - ds[j];
z[k] += w;
y[matchr[k]] -= w;
}
y[s] += ds[j];
while (dad[j] >= 0) {
int d = dad[j];
matchr[j] = matchr[d];
matchl[matchr[j]] = j;
j = d;
}
matchr[j] = s;
matchl[s] = j;
mat++;
}
coord value = 0;
for (int i = 0; i < N; i++) value += cst[i][matchl[i]];
return value;
}
int crd(char a) {
if (a >= 'a') return a - 'a';
return a - 'A' + 26;
}
int n, k, cs[66][66];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
string s, t;
cin >> s >> t;
for (int i = 0; i < n; i++) cs[crd(s[i])][crd(t[i])]++;
init(k, k);
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) add(i, j, -cs[i][j]);
cout << -hungarian() << '\n';
for (int i = 0; i < k; i++)
if (matchl[i] < 26)
cout << (char)('a' + matchl[i]);
else
cout << (char)('A' + matchl[i] - 26);
cout << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
long long int ans = 0;
if (b >= a) {
cout << b << endl;
continue;
}
ans = b;
if (d >= c) {
cout << "-1" << endl;
continue;
}
long long int finalans = ans;
long long int sleepleft = a - b;
long long int diff = c - d;
long long int x = sleepleft / diff;
long long int xx = x * diff + b;
if (xx < a) {
x = x + 1;
}
ans = b + c * x;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int findMaxDigit(int n) {
int res = 0;
while (n > 0) {
res = max(res, n % 10);
n /= 10;
}
return res;
}
int main() {
int a, b;
cin >> a >> b;
int maxDigit = max(findMaxDigit(a), findMaxDigit(b)) + 1;
int cnt = 0;
int left = 0;
while (a > 0 || b > 0 || left > 0) {
int sum = a % 10 + b % 10 + left;
left = sum / maxDigit;
a /= 10;
b /= 10;
cnt++;
}
cout << cnt << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double epsylon = 1e-9;
const std::string PROGRAM_NAME = "ivo";
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
long long w, t;
cin >> t >> w;
priority_queue<long long> pq;
vector<pair<long long, long long> > competition;
for (int i = 0; i < n - 1; ++i) {
long long tt, tw;
cin >> tt >> tw;
if (tt > t) {
pq.push(tt - tw - 1LL);
} else {
competition.push_back(make_pair(tt, tw));
}
}
int best = pq.size() + 1;
sort(competition.begin(), competition.end());
reverse(competition.begin(), competition.end());
int ix = 0;
while (t >= 0 && !pq.empty()) {
long long needed = -pq.top();
if (needed > t) {
break;
}
t -= needed;
pq.pop();
while (ix < (int)competition.size() && competition[ix].first > t) {
pq.push(competition[ix].first - competition[ix].second - 1LL);
ix++;
}
int cur = pq.size() + 1;
if (cur < best) {
best = cur;
}
}
cout << best << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int f = 0; f < t; ++f) {
int n;
cin >> n;
vector<int> v(2 * n);
for (int i = 0; i < 2 * n; ++i) {
cin >> v[i];
}
sort(v.begin(), v.end());
cout << abs(v[n] - v[n - 1]) << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
for (int i = 1; i < int(s.size()); ++i) {
if (s[i] < s[i - 1]) {
cout << "YES" << endl;
cout << i << " " << i + 1 << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
point() : x(0), y(0) {}
point(double a, double b) : x(a), y(b) {}
point operator+(point p) { return point(x + p.x, y + p.y); }
point operator-(point p) { return point(x - p.x, y - p.y); }
point operator*(double k) { return point(x * k, y * k); }
};
int N;
point P[1000];
double cross(point p, point q) { return p.x * q.y - p.y * q.x; }
double get_norm(point p) { return sqrt(p.x * p.x + p.y * p.y); }
bool isConvex(double d) {
for (int i = 0; i < N; i++) {
point u = P[(i + 2) % N] - P[i], v = point(-u.y, u.x) * (d / get_norm(u));
if (cross(v, u) * cross(P[(i + 1) % N] - P[i], u) < 0) v = v * (-1);
point a = P[i] + v, b = P[(i + 1) % N] - v, c = P[(i + 2) % N] + v;
if (cross(b - a, c - b) >= 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cin >> N;
for (int i = 0; i < N; i++) cin >> P[i].x >> P[i].y;
double a = 0, b = 1e9;
for (int i = 0; i < 100; i++) {
double m = (a + b) / 2;
if (isConvex(m))
a = m;
else
b = m;
}
cout << setprecision(10) << fixed << a;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> book;
int solution();
int main() {
cin >> n;
book.assign(n + 1, 0);
for (int i = 0; i < n; i++) cin >> book[i + 1];
cout << solution() << endl;
return 0;
}
int solution() {
int ans = 0;
int end = 0;
int start = 1;
while (start != n + 1) {
ans++;
end = book[end + 1];
for (int i = start; i <= end; i++) end = max(end, book[i]);
start = end + 1;
}
return ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime[2001];
vector<int> primes;
void gen() {
memset(isPrime, true, sizeof(isPrime));
for (int i = 2; i <= 2000; i++) {
if (isPrime[i]) {
primes.push_back(i);
for (int j = i * i; j <= 2000; j += i) {
isPrime[j] = false;
}
}
}
}
int main() {
gen();
string s;
cin >> s;
set<int> nums;
int l = --upper_bound(primes.begin(), primes.end(), (double)s.size() / 2) -
primes.begin();
int r =
--upper_bound(primes.begin(), primes.end(), s.size()) - primes.begin();
for (int i = l + 1; i <= r; i++) {
nums.insert(primes[i]);
}
nums.insert(1);
int diff = r - l + 1;
int same = s.size() - diff;
for (char c = 'a'; c <= 'z'; c++) {
if (count(s.begin(), s.end(), c) >= same) {
printf("YES\n");
for (int i = 0; i < s.size(); i++) {
if (s[i] != c) {
for (int p : nums) {
if (s[p - 1] == c) {
swap(s[p - 1], s[i]);
break;
}
}
}
}
cout << s << '\n';
return 0;
}
}
printf("NO\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
const double EPS = 1e-8;
const double PI = acos(-1.0);
int popcount(int n) { return __builtin_popcount(n); }
int popcount(long long n) { return __builtin_popcountll(n); }
template <class T>
int SIZE(T a) {
return a.size();
}
template <class T>
string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
template <class T>
T StringToInt(string str) {
T res = 0;
for (int i = 0; i < SIZE(str); i++) res = (res * 10 + str[i] - '0');
return res;
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
void PrintSeq(T &a, int sz) {
for (int i = 0; i < sz; i++) {
cout << a[i];
if (sz == i + 1)
cout << endl;
else
cout << ' ';
}
}
bool EQ(double a, double b) { return abs(a - b) < EPS; }
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
vector<string> split(string str, char del) {
vector<string> res;
for (int i = 0, s = 0; i < SIZE(str); i++) {
if (str[i] == del) {
if (i - s != 0) res.push_back(str.substr(s, i - s));
s = i + 1;
} else if (i == SIZE(str) - 1) {
res.push_back(str.substr(s));
}
}
return res;
}
int N;
int ary[2000011];
int main() {
cin >> N;
for (int i = 1; i <= N; i++) ary[i - 1] = i;
for (int t = 2; t <= N; t++) {
for (int i = t;; i += t) {
if (i >= N) {
i = N;
swap(ary[t - 2], ary[i + t - 2]);
break;
} else {
swap(ary[t - 2], ary[i + t - 2]);
}
}
}
for (int i = 0; i < N; i++) {
cout << ary[N - 1 + i] << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005, P = 1000000007;
using ll = long long;
int n, x[N], y[N], clr[N];
vector<int> v[N];
ll qpow(ll a, ll b) {
ll ret = 1;
while (b) {
if (b & 1) ret = ret * a % P;
a = a * a % P;
b >>= 1;
}
return ret;
}
bool vis[N];
bool bfs(int pos) {
clr[pos] = 0;
queue<int> q;
q.push(pos);
while (!q.empty()) {
int nd = q.front();
q.pop();
for (auto &i : v[nd])
if (clr[i] == -1)
clr[i] = clr[nd] ^ 1, q.push(i);
else if (clr[i] != clr[nd] ^ 1)
return 0;
}
return 1;
}
int check(int mid) {
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (abs(x[i] - x[j]) + abs(y[i] - y[j]) > mid)
v[i].push_back(j), v[j].push_back(i);
memset(clr, -1, sizeof(clr));
int cnt = 0;
for (int i = 1; i <= n; i++)
if (clr[i] == -1) {
if (!bfs(i)) return 0;
++cnt;
}
return qpow(2, cnt);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
int l = 0, r = 10000, ans = -1, cnt = 0;
while (l <= r) {
int mid = (l + r) >> 1, tmp;
if (tmp = check(mid))
ans = mid, r = mid - 1, cnt = tmp;
else
l = mid + 1;
}
cout << ans << endl << cnt << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007, dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
const double eps = 1e-8, pi = acos(-1);
void read(int &k) {
k = 0;
char x = getchar();
while (x < '0' || x > '9') x = getchar();
while (x >= '0' && x <= '9') {
k = k * 10 - 48 + x;
x = getchar();
}
}
struct point {
double x, y, z;
point() { z = 1; }
point(double xx, double yy, double zz) {
x = xx;
y = yy;
z = zz;
}
double operator*(point b) { return x * b.x + y * b.y + z * b.z; }
point operator*(double k) { return (point){k * x, k * y, z}; }
point operator/(point b) {
return (point){y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x};
}
point operator-(point b) { return (point){x - b.x, y - b.y, z}; }
point operator+(point b) { return (point){x + b.x, y + b.y, z}; }
void rotate(double theta) {
point T = *this;
x = T.x * cos(theta) - T.y * sin(theta);
y = T.x * sin(theta) + T.y * cos(theta);
}
void output() { printf("%.9lf %.9lf ", x, y); }
};
point V, P, WL, WR, ML, MR, dir, tP, tmp;
int cmp(double x, double y) {
if (fabs(x - y) < eps) return 0;
return x < y ? -1 : 1;
}
int inl(point x, point y, point z) { return cmp(x * (y / z), 0) == 0; }
point Normal(point y, point z) {
point tmp = z - y;
tmp.rotate(pi / 2);
return tmp;
}
point Mirror(point x, point y, point z) {
point nvec;
nvec = Normal(y, z);
point tmp = y / z, o, nxt;
o = (point){tmp.y, -tmp.x, 0};
o.z = -(x.x * o.x + x.y * o.y);
nxt = o / tmp;
nxt.x /= nxt.z;
nxt.y /= nxt.z;
nxt.z = 1;
return nxt * 2 - x;
}
int in(point x, point y, point z) {
int flag1 = 0, flag2 = 0;
if (cmp(x.x, y.x) >= 0 && cmp(x.x, z.x) <= 0) flag1 = 1;
if (cmp(x.x, z.x) >= 0 && cmp(x.x, y.x) <= 0) flag1 = 1;
if (cmp(x.y, y.y) >= 0 && cmp(x.y, z.y) <= 0) flag2 = 1;
if (cmp(x.y, z.y) >= 0 && cmp(x.y, y.y) <= 0) flag2 = 1;
return flag1 & flag2;
}
int intersect(point x0, point y0, point x1, point y1, point &ret) {
point l1, l2;
l1 = x0 / y0;
l2 = x1 / y1;
ret = l1 / l2;
if (cmp(ret.z, 0) == 0) return 0;
ret.x /= ret.z;
ret.y /= ret.z;
ret.z = 1;
return in(ret, x0, y0) && in(ret, x1, y1);
}
int cross(point x0, point y0, point x1, point y1) {
if (inl(x1, x0, y0) && inl(y1, x0, y0))
return in(x1, x0, y0) || in(y1, x0, y0) || in(x0, x1, y1) || in(y0, x1, y1);
point a = y0 - x0;
int flag1 = 0, flag2 = 0;
if (cmp(((x1 - x0) / a).z * ((y1 - x0) / a).z, 0) <= 0) flag1 = 1;
a = y1 - x1;
if (cmp(((x0 - x1) / a).z * ((y0 - x1) / a).z, 0) <= 0) flag2 = 1;
return flag1 & flag2;
}
int sgn(double x) { return cmp(x, 0); }
point midvectical(point x, point y) {
point ret = x / y, z = (x + y) * 0.5;
swap(ret.x, ret.y);
ret.y = -ret.y;
ret.z = -(z.x * ret.x + z.y * ret.y);
return ret;
}
point a0, a1, a2, a3, a4, a5;
point l0, l1, l2, b1, b2, b3, b4;
int solve(point a0, point a1, point a2) {
l0 = midvectical(a0, a1);
l1 = midvectical(a0, a2);
a3 = l0 / l1;
a3.x /= a3.z;
a3.y /= a3.z;
a3.z = 1;
l2 = l0;
l2.z = -(l2.x * a0.x + l2.y * a0.y);
a4 = l2 / l1;
a4.x /= a4.z;
a4.y /= a4.z;
a4.z = 1;
a5 = a4 * 2 - a3;
b1 = a2 * 2 - a5;
b2 = a5;
b3 = a0 * 2 - a5;
b4 = a1 * 2 - b3;
if (inl(b1, b2, b3) || inl(b1, b2, b4) || inl(b1, b3, b4) || inl(b2, b3, b4))
return 0;
double dir = sgn(((b3 - b1) / (b2 - b1)).z);
if (sgn(((b4 - b2) / (b3 - b2)).z) != dir) return 0;
if (sgn(((b1 - b3) / (b4 - b3)).z) != dir) return 0;
if (sgn(((b2 - b4) / (b1 - b4)).z) != dir) return 0;
puts("YES");
b1.output();
b2.output();
b3.output();
b4.output();
puts("");
return 1;
}
int main() {
int T;
for (scanf("%d", &T); T--;) {
scanf("%lf%lf%lf%lf%lf%lf", &a0.x, &a0.y, &a1.x, &a1.y, &a2.x, &a2.y);
if (a0 * (a1 / a2) == 0) {
puts("NO\n");
continue;
}
if (solve(a0, a1, a2)) continue;
if (solve(a0, a2, a1)) continue;
if (solve(a1, a0, a2)) continue;
if (solve(a1, a2, a0)) continue;
if (solve(a2, a0, a1)) continue;
if (solve(a2, a1, a0)) continue;
puts("NO\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
vector<long long int> v;
int aux[4];
int media() {
int x = 0;
for (int i = 0; i < 4; i++) x += aux[i];
return x;
}
int mediana() { return 2 * (aux[1] + aux[2]); }
int range() { return 4 * (aux[3] - aux[0]); }
pair<pair<int, int>, int> check3() {
int aux[4];
for (int i = 1; i <= 500; i++) {
for (int j = 1; j <= 500; j++) {
for (int k = 1; k <= 500; k++) {
aux[0] = v[0];
aux[1] = i;
aux[2] = j;
aux[3] = k;
sort(aux, aux + 4);
if (media() == mediana() and media() == range()) {
return make_pair(make_pair(i, j), k);
}
}
}
}
return make_pair(make_pair(-1, -1), -1);
}
pair<int, int> check2() {
for (int i = 1; i <= 5000; i++) {
for (int j = 1; j <= 5000; j++) {
aux[0] = v[0];
aux[1] = v[1];
aux[2] = i;
aux[3] = j;
sort(aux, aux + 4);
if (media() == mediana() and media() == range()) return make_pair(i, j);
}
}
return make_pair(-1, -1);
}
int check1() {
for (int i = 1; i <= 1000000; i++) {
aux[0] = v[0];
aux[1] = v[1];
aux[2] = v[2];
aux[3] = i;
sort(aux, aux + 4);
if (media() == mediana() and media() == range()) return i;
}
return -1;
}
int check() {
aux[0] = v[0], aux[1] = v[1], aux[2] = v[2], aux[3] = v[3];
return (media() == mediana() and media() == range());
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
v.push_back(x);
}
sort(v.begin(), v.end());
if (n == 0) {
puts("YES");
cout << 1 << "\n" << 1 << "\n" << 3 << "\n" << 3;
} else if (n == 1) {
puts("YES");
cout << 2 * v[0] << "\n";
cout << 2 * v[0] << "\n";
cout << 3 * v[0] << "\n";
} else if (n == 2) {
auto it = check2();
if (it.first == -1) {
puts("NO");
} else {
puts("YES");
cout << it.first << "\n" << it.second << "\n";
}
} else if (n == 3) {
auto it = check1();
if (it == -1) {
puts("NO");
} else {
puts("YES");
cout << it << "\n";
}
} else {
auto it = check();
if (it == 0)
puts("NO");
else
puts("YES");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, n, t, b, c, d, i, j, k, x, y, z, l, q, r;
long long cnt = 0, ans = 0;
string s, s1;
cin >> s;
x = s.size();
long long cntx = 0, cnty = 0;
for (long long i = 0; i < x; i++) {
if (s[i] == 'x')
cntx++;
else
cnty++;
}
if (cntx > cnty) {
cnt = cntx - cnty;
for (long long i = 0; i < cnt; i++) cout << "x";
} else {
cnt = cnty - cntx;
for (long long i = 0; i < cnt; i++) cout << "y";
}
return 0;
}
| 2 |
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
#include "bits/stdc++.h"
using namespace std;
#define int long long int
#define SYNC std::ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
typedef double ld;
typedef pair<ld,ld> ii;
typedef pair<int,ii> iii;
typedef vector<int> vi;
typedef vector<ii> vii;
#define rep(i,l,r) for (int i = (l); i < (r); i++)
#define here cout << " Hey!!\n";
#define pb push_back
#define F first
#define S second
#define all(v) (v).begin(),(v).end()
#define sz(a) (int)((a).size())
#define sq(x) ((x)*(x))
const int MOD = 1e9+7;
const int MOD1 = 998244353;
const int N = 2e5+5;
const ld INF = 1000111000111000111LL;
const ld EPS = 1e-6;
const ld PI = 3.141592653589793116;
ld dist (ii x, ii y) {
return sqrt(sq(x.F - y.F) + sq(x.S - y.S));
}
ld cal_angle(ii p, ii &eye) {
return atan((eye.S - p.S)/(eye.F - p.F));
}
int32_t main()
{
SYNC
int n; cin >> n;
ld H; cin >> H;
vector<pair<ld, ld>> v(n);
rep(i,0,n) {
int x, y; cin >> x >> y;
v[i] = {x, y};
}
ii eye = v[n-1];
eye.S += H;
if (n == 2) {
cout << fixed << setprecision(9) << dist(v[0], v[1]) ;
return 0;
}
vector<ld> a(n-1);
for (int i = 0; i < n - 1; i++) {
a[i] = cal_angle(v[i], eye);
}
for (int i = n - 3; i >= 0; i--) {
a[i] = min(a[i+1], a[i]);
}
ld ans = 0;
for (int i = 0; i < n - 1; i++) {
if (i == n-2) {
ans += dist(v[i], v[i+1]);
break;
}
ld lim = a[i+1];
ld lo = v[i].F, hi = v[i+1].F;
ld grad = (v[i+1].S - v[i].S) / (hi - lo);
int lol = 30;
while (lol--) {
ld mid = (lo + hi)/2;
ld y = v[i].S + grad * (mid - v[i].F);
ld now = cal_angle({mid, y}, eye);
if (now <= lim) {
lo = mid;
} else {
hi = mid;
}
}
ld y = v[i].S + grad * (lo - v[i].F);
ans += dist({lo, y}, v[i]);
}
cout << fixed << setprecision(9) << ans;
return 0;
} | 8 |
#include <bits/stdc++.h>
const double eps = 1e-9;
const double pi = acos(-1);
const int oo = 1000000000;
const int mod = 1000000007;
const double E = 2.7182818284590452353602874713527;
using namespace std;
string v[50] = {
"111111101010101111100101001111111", "100000100000000001010110001000001",
"101110100110110000011010001011101", "101110101011001001111101001011101",
"101110101100011000111100101011101", "100000101010101011010000101000001",
"111111101010101010101010101111111", "000000001111101111100111100000000",
"100010111100100001011110111111001", "110111001111111100100001000101100",
"011100111010000101000111010001010", "011110000110001111110101100000011",
"111111111111111000111001001011000", "111000010111010011010011010100100",
"101010100010110010110101010000010", "101100000101010001111101000000000",
"000010100011001101000111101011010", "101001001111101111000101010001110",
"101101111111000100100001110001000", "000010011000100110000011010000010",
"001101101001101110010010011011000", "011101011010001000111101010100110",
"111010100110011101001101000001110", "110001010010101111000101111111000",
"001000111011100001010110111110000", "000000001110010110100010100010110",
"111111101000101111000110101011010", "100000100111010101111100100011011",
"101110101001010000101000111111000", "101110100011010010010111111011010",
"101110100100011011110110101110000", "100000100110011001111100111100000",
"111111101101000101001101110010001"};
int main() {
int a, b;
cin >> a >> b;
cout << v[a][b] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> temp;
int main() {
ios_base::sync_with_stdio(0);
int n, q, l, r;
cin >> n >> q;
int arr[n + 1];
int L[n + 1];
int lft_nxt_grt[n + 1];
int rght_nxt_grt[n + 1];
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n - 1; i++) L[i] = abs(arr[i] - arr[i + 1]);
while (q--) {
cin >> l >> r;
stack<pair<int, int> > sl, sr;
sl.push({1e9, l - 1});
sr.push({1e9, r});
for (int i = l; i < r; i++) {
while (sl.top().first < L[i]) sl.pop();
lft_nxt_grt[i] = sl.top().second;
sl.push({L[i], i});
}
for (int i = r - 1; i >= l; i--) {
while (sr.top().first <= L[i]) sr.pop();
rght_nxt_grt[i] = sr.top().second;
sr.push({L[i], i});
}
long long sum = 0;
for (int i = l; i < r; i++)
sum += (long long)L[i] * (i - lft_nxt_grt[i]) * (rght_nxt_grt[i] - i);
cout << sum << "\n";
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define lson p<<1,l,mid
#define rson p<<1|1,mid+1,r
#define ls p<<1
#define rs p<<1|1
using namespace std;
const int maxn=3.5e4+5;
const int INF=2e9;
int pre[maxn],pos[maxn],dp[maxn],n,k,a[maxn];
struct SegmentTree{
int add[maxn<<2],mn[maxn<<2];
void pushUp(int p){
mn[p]=min(mn[ls],mn[rs]);
}
void build(int p,int l,int r){
add[p]=0;
if(l==r){
mn[p]=dp[l];return;
}
int mid=l+r>>1;
build(lson);
build(rson);
pushUp(p);
}
void pushDown(int p){
mn[ls]+=add[p];mn[rs]+=add[p];
add[ls]+=add[p];add[rs]+=add[p];
add[p]=0;
}
int query(int p,int l,int r,int L,int R){
if(L<=l&&r<=R)return mn[p];
if(add[p])pushDown(p);
int mid=l+r>>1,ans=INF;
if(L<=mid)ans=min(ans,query(lson,L,R));
if(R>mid)ans=min(ans,query(rson,L,R));
return ans;
}
void update(int p,int l,int r,int L,int R,int val){
if(L<=l&&r<=R){
mn[p]+=val;add[p]+=val;return;
}
if(add[p])pushDown(p);
int mid=l+r>>1;
if(L<=mid)update(lson,L,R,val);
if(R>mid)update(rson,L,R,val);
pushUp(p);
}
}tr;
int main(){
scanf("%d%d",&n,&k);
for(int i=1;i<=n;++i)scanf("%d",&a[i]);
for(int i=1;i<=n;++i){
pre[i]=pos[a[i]];
pos[a[i]]=i;
}
for(int i=1;i<=n;++i)dp[i]=INF;
dp[0]=0;
for(int j=1;j<=k;++j){
for(int i=0;i<j-1;++i)dp[i]=INF;
tr.build(1,0,n);
for(int i=j;i<=n;++i){
int val=(pre[i]?i-pre[i]:0);
if(pre[i]&&val)tr.update(1,0,n,0,pre[i]-1,val);
dp[i]=tr.query(1,0,n,j-1,i-1);
}
}
cout<<dp[n]<<"\n";
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, r, n, i;
cin >> k >> r;
if (k % 10 == 0) {
n = 1;
} else {
for (i = 1; i <= 1000000000; i++) {
if (k * i % 10 == 0) {
n = i;
break;
}
if (i * k % 10 - r == 0) {
n = i;
break;
}
}
}
cout << n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005][3];
long long s[100005], m, n;
long long fun(long long ans) {
int l = 1, r = m, mid;
while (l <= r) {
mid = (l + r) / 2;
if (s[mid] >= ans && s[mid - 1] < ans)
return mid;
else if (s[mid] < ans)
l = mid + 1;
else
r = mid - 1;
}
return mid;
}
long long findres(long long res) {
long long p = fun(res);
if (a[p][0] == 1) return a[p][1];
long long w = p;
p = res - s[p - 1];
p = p % a[w][1];
if (p == 0) p = a[w][1];
return findres(p);
}
int main() {
while (cin >> m) {
int i;
memset(a, 0, sizeof(a));
memset(s, 0, sizeof(s));
for (i = 1; i <= m; i++) {
cin >> a[i][0];
if (a[i][0] == 1) {
cin >> a[i][1];
if (i == 1)
s[i] = 1;
else
s[i] = s[i - 1] + 1;
} else {
cin >> a[i][1] >> a[i][2];
s[i] = s[i - 1] + a[i][1] * a[i][2];
}
}
cin >> n;
long long res;
for (i = 0; i < n; i++) {
cin >> res;
cout << findres(res) << " ";
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[100010];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int ans = 0;
int re = 0;
for (int i = 0; i < n; i++) {
int t = 1;
while (a[i + 1] == a[i] && (i < n - 1)) {
t += 1;
i += 1;
}
if (i == n - 1) {
cout << ans;
return 0;
} else if (i == n - 2) {
cout << ans + 1;
return 0;
}
re = max(re, i + 1);
if (t < (n - re)) {
re += t;
ans += t;
} else if (t == n - re) {
ans += t;
cout << ans;
return 0;
} else {
ans += (n - re);
cout << ans;
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, b, n, t, i = 0, z = 1;
scanf("%d %d %d %d", &k, &b, &n, &t);
while (n && z <= (t - b) * 1. / k) {
z = k * z + b;
--n;
}
printf("%d\n", n);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
int n, m, i, j, a[333][333], b[333][333], cc, ord[666][666], cenx, ceny,
cnt[180003];
long long ans;
struct node {
int x, y, col;
};
bool cmp(node x, node y) {
return ord[x.x - cenx + 300][x.y - ceny + 300] <
ord[y.x - cenx + 300][y.y - ceny + 300];
}
map<int, int> mp;
vector<node> v[180003];
int f(int x) {
if (mp.count(x)) return mp[x];
return mp[x] = ++cc;
}
queue<node> q;
void preorder() {
int i, j, c = 1;
ord[300][300] = 1;
for (((i)) = (1); ((i)) <= ((300)); ((i))++) {
for (((j)) = (1); ((j)) <= ((i * 2)); ((j))++)
ord[300 - i][300 - i + j] = ++c;
for (((j)) = (1); ((j)) <= ((i * 2)); ((j))++)
ord[300 - i + j][300 + i] = ++c;
for (((j)) = (1); ((j)) <= ((i * 2)); ((j))++)
ord[300 + i][300 + i - j] = ++c;
for (((j)) = (1); ((j)) <= ((i * 2)); ((j))++)
ord[300 + i - j][300 - i] = ++c;
}
}
int main() {
read(n);
read(m);
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
for (((j)) = (1); ((j)) <= ((m)); ((j))++) {
read(a[i][j]);
if (a[i][j]) a[i][j] = f(a[i][j]);
cnt[a[i][j]]++;
}
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
for (((j)) = (1); ((j)) <= ((m)); ((j))++) {
read(b[i][j]);
if (b[i][j] && b[i][j] != -1) b[i][j] = f(b[i][j]);
if (b[i][j] != -1) v[a[i][j]].push_back(node{i, j, b[i][j]});
}
preorder();
read(cenx);
read(ceny);
q.push(node{cenx, ceny, b[cenx][ceny]});
int k = a[cenx][ceny];
while (!q.empty()) {
int x = q.front().x, y = q.front().y, col = q.front().col;
q.pop();
if (!k) continue;
if (k == col) continue;
if (!cnt[k]) {
k = col;
continue;
}
cnt[col] += cnt[k];
ans += cnt[k];
cnt[k] = 0;
cenx = x;
ceny = y;
sort((v[k]).begin(), (v[k]).end(), cmp);
for (__typeof((v[k]).begin()) it = (v[k]).begin(); it != (v[k]).end(); it++)
q.push(*it);
v[k].clear();
k = col;
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
long long int x = 0, y = 0, z = 0, z1 = 0;
x = a - b;
y = a + b;
z = c - d;
z1 = c + d;
long long int x1 = 0, x2 = 0;
x1 = x * n;
x2 = y * n;
if (x2 >= z && x1 <= z1) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 100;
int dp[MAXN], pd[MAXN], S[MAXN], sum[MAXN][3][3], T[MAXN];
char C[] = {'R', 'G', 'B'};
int get(int l, int r, int c1, int c2) {
return sum[r][c1][c2] - sum[l][c1][c2];
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
string SS, TT;
cin >> SS >> TT;
int s = SS.size(), t = TT.size();
for (int i = 0; i < s; i++)
for (int j = 0; j < 3; j++)
if (SS[i] == C[j]) S[i] = j;
for (int i = 0; i < t; i++)
for (int j = 0; j < 3; j++)
if (TT[i] == C[j]) T[i] = j;
int lst = 0;
for (int i = 0; i < s; i++) {
dp[i] = t - 1;
for (int j = lst; j < t; j++)
if (T[j] == S[i]) {
dp[i] = j;
break;
}
lst = dp[i] + 1;
}
lst = 0;
for (int i = 0; i < t; i++) {
pd[i] = s - 1;
for (int j = lst; j < s; j++)
if (T[i] == S[j]) {
pd[i] = j;
break;
}
lst = pd[i] + 1;
}
for (int i = 0; i < t; i++) {
for (int c = 0; c < 3; c++)
for (int c2 = 0; c2 < 3; c2++) sum[i + 1][c][c2] = sum[i][c][c2];
if (i < t - 1) sum[i + 1][T[i]][T[i + 1]]++;
}
long long ans = 0;
for (int i = 0; i < s; i++) {
int mk = lower_bound(pd, pd + t, i) - pd;
if (mk == t) continue;
ans += dp[i] - mk + 1;
if (i && S[i] != S[i - 1]) ans -= get(mk, dp[i], S[i], S[i - 1]);
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
vector<int> g(n + 1, 0);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a]++;
g[b]++;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (g[i] < 2) ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 8e5 + 5;
int n, m, las, res, cnt = 1, ans, use[N], du[N], head[N];
struct Edge {
int nxt, to;
} G[N];
template <typename _Tp>
inline void IN(_Tp& x) {
char ch;
bool flag = 0;
x = 0;
while (ch = getchar(), !isdigit(ch))
if (ch == '-') flag = 1;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
if (flag) x = -x;
}
inline void addedge(int u = 0, int v = 0) {
if (!u) IN(u), IN(v);
++du[u], ++du[v];
G[++cnt] = (Edge){head[u], v}, head[u] = cnt, G[++cnt] = (Edge){head[v], u},
head[v] = cnt;
}
void dfs(int u) {
for (int& i = head[u]; i; i = G[i].nxt)
if (!use[i]) {
use[i] = use[i ^ 1] = true;
int p = i;
dfs(G[p].to), ++res;
(res & 1) ? printf("%d %d\n", u, G[p].to) : printf("%d %d\n", G[p].to, u);
}
}
int main() {
IN(n), IN(m), ans = m;
for (int i = 1; i <= m; ++i) addedge();
for (int i = 1; i <= n; ++i)
if (du[i] & 1)
if (las)
addedge(i, las), ++ans, las = 0;
else
las = i;
if (ans & 1) ++ans, addedge(1, 1);
printf("%d\n", ans), dfs(1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int pages[7];
for (int i = 0; i < 7; i++) {
cin >> pages[i];
}
int ans = 0;
int days = 0;
while (n > 0) {
n -= pages[days % 7];
days++;
}
cout << ((days - 1) % 7) + 1 << "\n";
}
int main() { solve(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[3], ans = "";
int m[3] = {0};
map<char, int> k;
cin >> s[0] >> s[1] >> s[2];
for (int i = 0; i < 3; i++) {
if (s[i][1] == '<') {
k[s[i][2]]++;
} else {
k[s[i][0]]++;
}
}
if (k.size() != 2) {
cout << "Impossible" << endl;
return 0;
}
for (int j = 0; j < 3; j++) {
for (int i = 0; i < 3; i++) {
if (k['A' + i] == j && j == 0) ans += char('A' + i);
if (k['A' + i] == j && j == 1) ans += char('A' + i);
if (k['A' + i] == j && j == 2) ans += char('A' + i);
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
ifstream in;
ofstream out;
const long long kk = 1000;
const long long ml = kk * kk;
const long long mod = ml * kk + 7;
const long long inf = ml * ml * ml + 7;
long long n, i, j;
vector<long long> m;
bool viv = false;
void solve() {
long long a, b, n;
cin >> a >> b >> n;
n %= 3;
if (n == 0) return void(cout << a << endl);
if (n == 1) return void(cout << b << endl);
if (n == 2) return void(cout << (a ^ b) << endl);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2 * 1e5 + 4;
long long add(long long a, long long b, long long m) {
if (a < 0) a += m;
if (b < 0) b += m;
long long res = ((a % m) + (b % m)) % m;
res %= m;
return res;
}
long long mul(long long a, long long b, long long m) {
if (a < 0) a += m;
if (b < 0) b += m;
long long res = ((a % m) * (b % m)) % m;
res %= m;
return res;
}
long long sub(long long a, long long b, long long m) {
long long res = (a - b + m) % m;
res %= m;
return res;
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
sort((a).begin(), (a).end());
for (long long i = 1; i < n; i += 2) {
swap(a[i], a[i - 1]);
}
long long res = 0;
for (long long i = 1; i < n - 1; i++) {
if (a[i] < a[i + 1] and a[i] < a[i - 1]) res++;
}
cout << res << '\n';
for (auto x : a) cout << x << " ";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, q, bl, cnt, ans[700100], a[10010], pos[10010], f[800][260][260];
vector<pair<int, int> > mg;
int merge(int x, int y) {
if (!x || !y)
return x | y;
else
return mg.push_back(make_pair(x, y)), ++cnt;
}
struct point {
int l, r, g[260][260], p[4100];
void solve(int x, int l, int r, vector<int> v) {
if (l == r) return f[x][1][1] = pos[v[1]], void();
int mid = (l + r) >> 1;
vector<int> vl, vr;
vl.push_back(0);
vr.push_back(0);
for (int i = 1; i < v.size(); i++)
v[i] <= mid ? vl.push_back(v[i]) : vr.push_back(v[i]);
solve(x << 1, l, mid, vl);
solve(x << 1 | 1, mid + 1, r, vr);
int l1 = 1, l2 = 0, r1 = 1, r2 = 0;
for (int i = 1; i < v.size(); i++) {
for (int j = i; j < v.size(); j++) {
v[j] <= mid ? l2++ : r2++;
f[x][i][j] = merge(f[x << 1][l1][l2], f[x << 1 | 1][r1][r2]);
}
v[i] <= mid ? l1++ : r1++;
l2 = l1 - 1, r2 = r1 - 1;
}
}
int query(int l, int r) { return g[p[l - 1] + 1][p[r]]; }
} t[65];
int main() {
scanf("%d%d", &n, &q);
bl = 256;
cnt = n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
for (int i = 1; i <= (n - 1) / bl + 1; i++) {
t[i].l = (i - 1) * bl + 1;
t[i].r = min(n, i * bl);
vector<int> v;
v.push_back(0);
for (int j = 1; j <= n; j++) {
if (a[j] >= t[i].l && a[j] <= t[i].r) v.push_back(a[j]);
t[i].p[j] = v.size() - 1;
}
t[i].solve(1, t[i].l, t[i].r, v);
for (int j = 1; j < v.size(); j++)
for (int k = j; k < v.size(); k++) t[i].g[j][k] = f[1][j][k];
}
for (int i = 1, l, r; i <= q; i++) {
scanf("%d%d", &l, &r);
for (int j = 1; j <= (n - 1) / bl + 1; j++)
ans[i] = merge(ans[i], t[j].query(l, r));
}
printf("%d\n", cnt);
for (int i = 0; i < mg.size(); i++)
printf("%d %d\n", mg[i].first, mg[i].second);
for (int i = 1; i <= q; i++) printf("%d ", ans[i]);
puts("");
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, x[60];
double f[60][60], g[60][60], w[60][60][60][60], p;
vector<int> a[60];
inline void dp(int i, int j) {
vector<int> u;
u.clear();
x[i] = 1;
for (auto k : a[i])
if (k != j) {
dp(k, i);
x[i] += x[k];
u.push_back(k);
}
if (u.size()) {
int k, l, v, a, b, c, d;
for (k = u.size() - 1; k >= 0; k--) {
a = u[k];
if (k == u.size() - 1) {
for (l = 0; l <= n; l++) g[a][l] = f[a][l];
d = x[a];
} else {
b = u[k + 1];
c = x[a];
for (l = 0; l <= n; l++)
for (v = 0; v <= l; v++)
g[a][l] += w[c + d][l][c][v] * f[a][v] * g[b][l - v];
d += c;
}
}
for (k = 0; k <= d + 1; k++) {
for (l = 1; l <= d + 1; l++)
if (l > k)
f[i][k] += g[a][l - 1] / 2;
else
f[i][k] += g[a][k - 1];
f[i][k] /= d + 1;
}
if (!j) p = g[a][0];
} else {
f[i][0] = 0.5;
f[i][1] = 1;
}
}
inline void orz(int t) {
int i, j, k;
for (i = 1; i <= n; i++)
for (j = 0; j <= n; j++) f[i][j] = g[i][j] = 0;
p = 1;
dp(t, 0);
printf("%.10lf\n", p);
}
int main() {
int i, j, k, l;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d", &j, &k);
a[j].push_back(k);
a[k].push_back(j);
}
for (i = 0; i <= n; i++)
for (j = 0; j <= i; j++)
for (k = 0; k <= i; k++)
if (!i || !j || !k)
w[i][j][k][0] = 1;
else
for (l = 0; l <= j && l <= k; l++)
w[i][j][k][l] = ((l ? k * w[i - 1][j - 1][k - 1][l - 1] : 0) +
(i - k) * w[i - 1][j - 1][k][l]) /
i;
for (i = 1; i <= n; i++) orz(i);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
string s2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
long long int visit[500];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
visit[a[i]] = 1;
}
long long int m;
cin >> m;
long long int b[m];
for (long long int i = 0; i < m; i++) {
cin >> b[i];
visit[b[i]] = 1;
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
long long int p = a[i] + b[j];
if (visit[p] == 0) {
cout << a[i] << " " << b[j] << endl;
return 0;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void pr1(int x) { write(x), putchar(' '); }
inline void pr2(int x) { write(x), puts(""); }
int n, a[1000010], fa[2000010], s[2000010];
inline int getp(int p) {
if (p > n)
return p - n;
else
return p;
}
inline int findfa(int x) {
if (fa[x] == x)
return x;
else {
int ul = fa[x];
fa[x] = findfa(fa[x]);
s[x] += s[ul];
return fa[x];
}
}
int main() {
n = read();
int q = read(), he = 2 * n;
for (int i = 1; i <= n; i++) a[i] = read();
while (q--) {
int d = read(), ans = n, p = 1, sum = 0;
for (int i = 1; i <= he; i++) {
if (i > n) findfa(i - n), ans = min(ans, s[i - n] + 1);
sum += a[getp(i)];
fa[i] = i, s[i] = 0;
while (sum > d) {
fa[p] = i, s[p] = 1;
sum -= a[getp(p)], p++;
}
}
pr2(ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int a, b, c;
cin >> a >> b >> c;
int aux = abs(a) + abs(b);
if (c >= aux and (c - aux) % 2 == 0) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
void read(Tp &x) {
x = 0;
int fh = 1;
char ch = 1;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') fh = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= fh;
}
template <typename Tp>
void biread(Tp &x) {
x = 0;
int fh = 1;
char ch = 1;
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') fh = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 2 + ch - '0', ch = getchar();
x *= fh;
}
const int maxn = 100000 + 7;
const int maxm = 200000 + 7;
const int maxans = 1000000 + 7;
int n;
int Head[maxn], to[maxm], Next[maxm], tot;
int deg[maxn];
int rout[2][maxans], ans;
void addedge(int x, int y) {
to[++tot] = y, Next[tot] = Head[x], Head[x] = tot;
}
void add(int x, int y) {
addedge(x, y);
addedge(y, x);
}
void Init(void) {
read(n);
for (int i = 1, x, y; i < n; i++) {
read(x);
read(y);
add(x, y);
deg[x]++, deg[y]++;
}
}
void dfs(int x, int t, int f) {
rout[0][++ans] = x, rout[1][ans] = t;
int l = t, r = t;
while (r - l < deg[x] && l > 0) l--;
while (r - l < deg[x]) r++;
if (t == r) {
rout[0][++ans] = x, rout[1][ans] = l;
t = l;
}
for (int i = Head[x]; i; i = Next[i]) {
int y = to[i];
if (y == f) continue;
dfs(y, ++t, x);
rout[0][++ans] = x, rout[1][ans] = t;
if (x != 1 && t == r) {
t = 0, rout[0][++ans] = x, rout[1][ans] = 0;
}
}
}
void Work(void) {
if (n == 1) {
puts("1");
puts("1 0");
return;
}
dfs(1, 0, 0);
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) {
printf("%d %d\n", rout[0][i], rout[1][i]);
}
}
int main(void) {
Init();
Work();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node() : vis(0), comp(-1) {}
int vis;
int comp;
vector<int> adj;
};
vector<int> vis;
bool dfs(vector<vector<int> >& a, int u, string& res) {
vis[u] = true;
for (int i = 0; i < a.size(); i++) {
if (i == u) continue;
if (vis[i] == false) {
if (a[u][i] == 0) {
if (res[u] == 'b') res[u] = 'a';
res[i] = (res[u] == 'a') ? 'c' : 'a';
if (!dfs(a, i, res)) return false;
}
} else {
if (a[u][i] == 0) {
if (res[u] == res[i]) return false;
}
}
}
return true;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int> > a(n, vector<int>(n));
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
a[u][v] = 1;
a[v][u] = 1;
}
string res(n, 'b');
vis.assign(n, false);
for (int i = 0; i < n; i++) {
if (vis[i] == false) {
if (!dfs(a, i, res)) {
cout << "No" << endl;
return 0;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (abs(res[i] - res[j]) == 2 && a[i][j] == 1) {
cout << "No" << endl;
return 0;
}
if (abs(res[i] - res[j]) <= 1 && a[i][j] == 0) {
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[100000], b = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
if (a[i] != a[i + 1]) b++;
}
cout << b;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int OO = 1000000000;
char g[1005][1005];
vector<pair<int, int>> r[1005];
vector<pair<int, int>> c[1005];
int k, a[100005];
char t[100005];
bool go(int x, int y) {
for (int i = 0; i < k; i++) {
if (t[i] == 'N' || t[i] == 'S') {
if (t[i] == 'N') x = x - a[i];
auto it = lower_bound(c[y].begin(), c[y].end(), make_pair(x + 1, 0));
if (c[y].empty() || it == c[y].begin()) return false;
it--;
if (it->second < x + a[i]) return false;
if (t[i] == 'S') x = x + a[i];
} else {
if (t[i] == 'W') y = y - a[i];
auto it = lower_bound(r[x].begin(), r[x].end(), make_pair(y + 1, 0));
if (r[x].empty() || it == r[x].begin()) return false;
it--;
if (it->second < y + a[i]) return false;
if (t[i] == 'E') y = y + a[i];
}
}
return true;
}
int main() {
int n, m, l = 0;
string ans = "";
cin >> n >> m;
for (int i = 0; i < n; i++) {
l = 0;
for (int j = 0; j < m; j++) {
cin >> g[i][j];
if (g[i][j] == '#') {
if (l != j) r[i].push_back(make_pair(l, j - 1));
l = j + 1;
}
}
}
for (int j = 0; j < m; j++) {
l = 0;
for (int i = 0; i < n; i++)
if (g[i][j] == '#') {
if (l != i) c[j].push_back(make_pair(l, i - 1));
l = i + 1;
}
}
cin >> k;
for (int i = 0; i < k; i++) cin >> t[i] >> a[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] != '#' && g[i][j] != '.' && go(i, j)) ans += g[i][j];
sort(ans.begin(), ans.end());
cout << (ans == "" ? "no solution" : ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 79, logn = 20, maxn = 3e5 + 79;
vector<vector<int> > rmql(logn, vector<int>(maxn, inf)),
rmqr(logn, vector<int>(maxn, -inf));
vector<vector<int> > l(logn, vector<int>(maxn, inf)),
r(logn, vector<int>(maxn, -inf));
vector<int> logs(maxn, 0);
int mini(int i1, int i2) { return (l[0][i1] < l[0][i2] ? i1 : i2); }
int maxi(int i1, int i2) { return (r[0][i1] > r[0][i2] ? i1 : i2); }
void query(int l, int r, int& ansl, int& ansr) {
int s = logs[r - l + 1];
ansl = mini(rmql[s][l], rmql[s][r - (1 << s) + 1]);
ansr = maxi(rmqr[s][l], rmqr[s][r - (1 << s) + 1]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n == 1) {
cout << "0\n";
return 0;
}
vector<int> d(3 * n);
for (int i = 0; i < n; i++) cin >> d[i], d[i + n] = d[i + 2 * n] = d[i];
for (int i = 0; i < 3 * n; i++) {
l[0][i] = max(0, i - d[i]);
r[0][i] = min(3 * n - 1, i + d[i]);
if (i > 1) logs[i] = logs[i / 2] + 1;
}
for (int i = 0; i < 3 * n; i++) rmql[0][i] = rmqr[0][i] = i;
for (int i = 1; i < logn; i++) {
for (int j = 0; j + (1 << i) <= 3 * n; j++) {
rmql[i][j] = mini(rmql[i - 1][j], rmql[i - 1][j + (1 << (i - 1))]);
rmqr[i][j] = maxi(rmqr[i - 1][j], rmqr[i - 1][j + (1 << (i - 1))]);
}
}
for (int i = 1; i < logn; i++) {
for (int j = 0; j < 3 * n; j++) {
int nwl, nwr;
query(l[i - 1][j], r[i - 1][j], nwl, nwr);
l[i][j] = min(l[i - 1][nwl], l[i - 1][nwr]);
r[i][j] = max(r[i - 1][nwl], r[i - 1][nwr]);
}
}
for (int i = 0; i < n; i++) {
int ans = 1, myl = n + i, myr = n + i;
for (int j = logn - 1; j >= 0; j--) {
int nwl = min(l[j][myl], l[j][myr]), nwr = max(r[j][myl], r[j][myr]);
if (nwr - nwl + 1 < n) {
int tmpl = l[j][myl], tmpr = r[j][myr];
query(tmpl, tmpr, myl, myr);
ans += (1 << j);
}
}
cout << ans << " \n"[i == n - 1];
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
map<int, vector<int> > pos;
map<int, int> result;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (pos.find(t) == pos.end()) {
vector<int> temp;
temp.push_back(i + 1);
pos.insert(pair<int, vector<int> >(t, temp));
} else {
pos[t].push_back(i + 1);
}
}
for (map<int, vector<int> >::iterator iter = pos.begin(); iter != pos.end();
iter++) {
int len = iter->second.size();
if (len == 1) {
result.insert(pair<int, int>(iter->first, 0));
continue;
}
int count = 2;
int diff = iter->second[1] - iter->second[0];
for (int i = 1; i < len - 1; i++) {
if (diff != iter->second[i + 1] - iter->second[i]) break;
count++;
}
if (count == len) result.insert(pair<int, int>(iter->first, diff));
}
cout << result.size() << endl;
for (map<int, int>::iterator iter = result.begin(); iter != result.end();
iter++)
cout << iter->first << " " << iter->second << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int sum1 = 0, x;
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
sum1 += x;
}
int sum2 = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
sum2 += x;
}
printf("%s\n", sum1 >= sum2 ? "Yes" : "No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long tests = 1LL;
cin >> tests;
for (int testno = 1; testno < tests + 1; testno++) {
long long n;
cin >> n;
vector<long long> a(n);
long long sum = 0;
set<long long> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
}
if ((int)s.size() == 1)
cout << n << '\n';
else
cout << "1" << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Mod {
static const auto P = static_cast<int>(1e9 + 7);
ll k;
Mod() = default;
Mod(const ll k) : k(k % P) {}
};
Mod operator+(const Mod a, const Mod b) { return a.k + b.k; }
Mod operator*(const Mod a, const Mod b) { return a.k * b.k; }
Mod& operator+=(Mod& a, const Mod b) { return a = a + b; }
struct Residue {
Mod a, b;
};
Residue operator+(const Residue x, const Residue y) {
return {x.a + y.a, x.b + y.b};
}
Residue operator*(const Residue x, const Residue y) {
const auto a = x.a * y.a + x.b * y.b;
const auto b = x.a * y.b + x.b * y.a + x.b * y.b;
return {a, b};
}
Residue power(const Residue x, const int k) {
if (k == 0)
return {1, 0};
else if (k % 2 == 0)
return power(x * x, k / 2);
else
return x * power(x * x, k / 2);
}
struct Segment {
Residue sum, lazy_update;
};
Segment operator+(const Segment a, const Segment b) {
return {a.sum + b.sum, {1, 0}};
}
Segment operator*(const Segment a, const Residue f) {
return {a.sum * f, a.lazy_update * f};
}
Segment& operator*=(Segment& a, const Residue f) { return a = a * f; }
struct SegmentTree {
int N;
vector<Segment> data;
SegmentTree(const int N, const vector<int>& initial) : N(N) {
data = vector<Segment>(2 * N);
for (auto i = 0; i < N; i++)
data[N + i] = {power({0, 1}, initial[i]), {1, 0}};
for (auto i = N - 1; i >= 1; i--) data[i] = data[2 * i] + data[2 * i + 1];
}
void update(const int a, const int b, const int k) {
const auto f = power({0, 1}, k);
for (auto i = a + N, j = b + N + 1; i < j; i /= 2, j /= 2) {
if (i % 2) data[i++] *= f;
if (j % 2) data[--j] *= f;
}
push(a + N);
push(b + N);
}
void push(int i) {
for (i /= 2; i >= 1; i /= 2)
data[i] = (data[2 * i] + data[2 * i + 1]) * data[i].lazy_update;
}
Mod query(const int a, const int b) {
pull(a + N);
pull(b + N);
auto result = Mod(0);
for (auto i = a + N, j = b + N + 1; i < j; i /= 2, j /= 2) {
if (i % 2) result += data[i++].sum.b;
if (j % 2) result += data[--j].sum.b;
}
return result;
}
void pull(const int i) {
if (i == 1) return;
const auto parent = i / 2;
pull(parent);
data[2 * parent] = data[2 * parent] * data[parent].lazy_update;
data[2 * parent + 1] = data[2 * parent + 1] * data[parent].lazy_update;
data[parent].lazy_update = {1, 0};
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
auto initial = vector<int>(n);
for (auto& x : initial) cin >> x;
auto tree = SegmentTree(n, initial);
for (auto i = 0; i < m; i++) {
int type, left, right;
cin >> type >> left >> right;
left--;
right--;
if (type == 1) {
int x;
cin >> x;
tree.update(left, right, x);
} else
cout << tree.query(left, right).k << "\n";
}
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pushb push_back
#define popb pop_back
int main()
{
// your code goes here
int t;
cin>>t;
while(t--)
{
int w,h,n;
cin>>w>>h>>n;
int count=1;int counter=1;
while(w%2==0 && w>0)
{
count=count*2;
w/=2;
}
while(h%2==0 && h>0)
{
//count++;
counter=counter*2;
h/=2;
}
int total=0;
total+= (count*counter);
if(total>=n)
{
cout<<"YES";
}
else
{
cout<<"NO";
}
cout<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, bool> visi;
vector<long long> v;
int ar[1000001];
int vis[1000001];
int xx[10001];
int yy[1001][1001];
int r;
char str[1009][1009];
int n, m, sum, lol;
int main() {
int i, j, a, c, b, ck, t, x, y, ans, rem, k, cnt, mid, lo, hi, key, cs = 1;
char ch;
scanf("%d%d", &n, &m);
a = cnt = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf(" %c", &str[i][j]);
if (str[i][j] == '*') {
yy[i][j] = yy[i - 1][j] + 1;
cnt++;
a++;
} else
yy[i][j] = yy[i - 1][j];
}
xx[i] = a;
a = 0;
}
ck = 0;
if (cnt == 0)
printf("YES\n1 1\n");
else {
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
sum = xx[i] + yy[n][j];
if (str[i][j] == '*') sum = sum - 1;
if (sum == cnt) {
printf("YES\n%d %d\n", i, j);
ck = 1;
break;
}
}
if (ck == 1) break;
}
if (ck == 0) printf("NO\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
int N, M, Now;
int Tot, Head[MaxN], Next[MaxN << 1], To[MaxN << 1], Num[MaxN << 1];
int Root, Size[MaxN], F[MaxN];
int Pow1[MaxN], Pow2[MaxN], A[MaxN], B[MaxN], Dep[MaxN];
bool Vis[MaxN];
long long X, Y, Inv, Ans;
map<int, int> Map1, Map2;
int ExGCD(int a, int b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
int d = ExGCD(b, a % b, x, y);
long long t = x;
x = y, y = t - a / b * y;
return d;
}
void Add_Edge(int u, int v, int w) {
Next[++Tot] = Head[u];
To[Tot] = v, Num[Tot] = w;
Head[u] = Tot;
}
void Get_Root(int u, int fa) {
int i, v;
Size[u] = 1, F[u] = 0;
for (i = Head[u]; i; i = Next[i])
if ((v = To[i]) != fa && !Vis[v]) {
Get_Root(v, u);
Size[u] += Size[v];
F[u] = max(F[u], Size[v]);
}
F[u] = max(F[u], Now - Size[u]);
if (F[Root] > F[u]) Root = u;
}
void Get_Size(int u, int fa) {
int i, v;
Size[u] = 1;
for (i = Head[u]; i; i = Next[i])
if ((v = To[i]) != fa && !Vis[v]) {
Get_Size(v, u);
Size[u] += Size[v];
}
}
void Calc(int u, int fa) {
int i, v;
Ans += (A[u] == 0) + (B[u] == 0);
Ans += Map2[(M - A[u]) % M] + Map1[1ll * B[u] * Pow2[Dep[u]] % M];
for (i = Head[u]; i; i = Next[i])
if ((v = To[i]) != fa && !Vis[v]) {
A[v] = (1ll * Num[i] * Pow1[Dep[u]] % M + A[u]) % M;
B[v] = (1ll * B[u] * 10 % M + Num[i]) % M;
Dep[v] = Dep[u] + 1;
Calc(v, u);
}
}
void Update(int u, int fa, int x) {
int i, v;
Map1[(M - A[u]) % M] += x;
Map2[1ll * B[u] * Pow2[Dep[u]] % M] += x;
for (i = Head[u]; i; i = Next[i])
if ((v = To[i]) != fa && !Vis[v]) Update(v, u, x);
}
void DFS(int u) {
int i, v;
Vis[u] = true;
Get_Size(u, 0);
for (i = Head[u]; i; i = Next[i])
if (!Vis[v = To[i]]) {
A[v] = B[v] = Num[i] % M;
Dep[v] = 1;
Calc(v, 0);
Update(v, 0, 1);
}
for (i = Head[u]; i; i = Next[i])
if (!Vis[v = To[i]]) Update(v, 0, -1);
for (i = Head[u]; i; i = Next[i])
if (!Vis[v = To[i]]) {
Root = 0, Now = Size[v];
Get_Root(v, 0);
DFS(Root);
}
}
int main() {
int i, u, v, w;
scanf("%d%d", &N, &M);
for (i = 1; i < N; i++) {
scanf("%d%d%d", &u, &v, &w);
u++, v++;
Add_Edge(u, v, w);
Add_Edge(v, u, w);
}
ExGCD(10, M, X, Y);
Inv = (X + M) % M;
Pow1[0] = Pow2[0] = 1;
for (i = 1; i <= N; i++) {
Pow1[i] = 1ll * Pow1[i - 1] * 10 % M;
Pow2[i] = 1ll * Pow2[i - 1] * Inv % M;
}
F[0] = 1 << 30, Now = N;
Get_Root(1, 0);
DFS(Root);
printf("%I64d\n", Ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
vector<int> g[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i) sort(g[i].begin(), g[i].end());
vector<int> tmp(n);
iota(tmp.begin(), tmp.end(), 1);
set<int> unreached(tmp.begin(), tmp.end());
int res = -1;
for (int start = 1; start <= n; ++start)
if (!unreached.empty() && start == *unreached.begin()) {
queue<int> q;
q.push(start);
unreached.erase(unreached.begin());
while (!q.empty()) {
int u = q.front();
q.pop();
vector<int> new_reached;
set_difference(unreached.begin(), unreached.end(), g[u].begin(),
g[u].end(), back_inserter(new_reached));
for (int v : new_reached) {
q.push(v);
unreached.erase(v);
}
}
++res;
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char c[1001][1001];
int m, n, t;
long long f[1001][1001];
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d%d", &m, &n, &t);
for (int i = 1; i <= m; ++i) {
scanf(" %s", c[i] + 1);
for (int j = 1; j <= n; ++j) {
f[i][j] = 2000000000000000000LL;
}
}
queue<int> qx, qy;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
bool ok = true;
for (int d = 0; d < 4; ++d) {
int u = i + dx[d], v = j + dy[d];
if (u >= 1 && u <= m && v >= 1 && v <= n) {
if (c[i][j] == c[u][v]) {
ok = false;
break;
}
}
}
if (!ok) {
f[i][j] = 0;
qx.push(i);
qy.push(j);
}
}
}
while (!qx.empty()) {
int x = qx.front();
qx.pop();
int y = qy.front();
qy.pop();
for (int d = 0; d < 4; ++d) {
int u = x + dx[d], v = y + dy[d];
if (u >= 1 && u <= m && v >= 1 && v <= n) {
if (f[u][v] == 2000000000000000000LL) {
f[u][v] = f[x][y] + 1;
qx.push(u);
qy.push(v);
}
}
}
}
long long i, j, p;
while (t--) {
scanf("%lld%lld%lld", &i, &j, &p);
if ((p < f[i][j]) || (p >= f[i][j] && ((p - f[i][j]) % 2 == 0))) {
printf("%d\n", c[i][j] - '0');
} else {
printf("%d\n", 1 - (c[i][j] - '0'));
}
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.