solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 2e5 + 5;
const int OO = 1e9;
const double PI = acos(-1);
const double EPS = 1e-8;
long long fastpow(long long b, long long e) {
if (!e) return 1;
long long ret = fastpow(b, e / 2);
ret = (ret * ret) % mod;
if (e % 2) ret = (ret * b) % mod;
return ret;
}
long long mi(int x) { return fastpow(x, mod - 2); }
int n, a[N];
long long dp[N][3];
int vis[N][3];
long long solve(int x, bool ch) {
if (x <= 0 || x > n) return 0;
if (dp[x][ch] != -1) return dp[x][ch];
if (vis[x][ch]) return -2;
vis[x][ch] = 1;
long long ret = solve(x + (ch ? a[x] : -a[x]), !ch);
if (ret == -2) return -2;
return dp[x][ch] = ret + a[x];
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
long long res = solve(i + 1, 0);
printf("%lld\n", res == -2 ? -1 : res + i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[200001], now = 1;
vector<int> s;
void wk(int x) {
s.push_back(x);
while (!s.empty() && s.back() == now) s.pop_back(), now++;
}
int main() {
int n, k;
cin >> n >> k;
s.push_back(n + 1);
for (int x = 1; x <= k; x++) cin >> a[x], wk(a[x]);
for (int x = k + 1; x <= n; x++) a[x] = s.back() - 1, wk(a[x]);
if (!s.empty()) return 0 * puts("-1");
for (int x = 1; x <= n; x++) cout << a[x] << ' ';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, cnt = 0, a[200], in[200];
vector<int> ans;
bool ss(int x, int y) { return a[x] < a[y]; }
int main() {
for (int i = 0; i < 200; i++) in[i] = i;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(in, in + n, ss);
for (int i = 0; i < n; i++) {
if (k >= a[in[i]]) {
k -= a[in[i]];
ans.push_back(in[i] + 1);
}
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200005];
bool used[200005];
int main() {
int T;
cin >> T;
while (T--) {
cin >> n;
for (int i = 0; i < n; i++) used[i] = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i] = (i + a[i]) % n;
if (a[i] < 0) a[i] += n;
used[a[i]] = 1;
}
bool ok = 1;
for (int i = 0; i < n; i++)
if (used[i] == 0) ok = 0;
if (!ok)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
vector<long long> cur(n);
for (long long i = 0; i < n; i++) {
cur[i] = a[i] * (i + 1) * (n - i);
}
sort(cur.begin(), cur.end());
sort(b.rbegin(), b.rend());
long long res = 0;
for (long long i = 0; i < n; i++) {
res = (res + (b[i] * (cur[i] % MOD))) % MOD;
}
cout << res % MOD << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
char s[N];
int n, m, k, d;
int Left[N], Sort[N], All[N], Cur[N], tt[N];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 1; i < n; i++) Left[i] = i - 1;
Left[0] = n - 1;
scanf("%d", &m);
for (int ii = 1; ii <= m; ii++) {
scanf("%d%d", &k, &d);
for (int i = 0; i < n; i++) Sort[i] = i;
int tot = 0;
for (int i = 0; i < d; i++)
for (int j = i; j < k; j += d) Sort[j] = tot++;
for (int i = 0; i < n; i++) Cur[i] = Sort[i];
for (int i = 0; i < n; i++) All[i] = Sort[Left[i]];
int Times = n - k;
while (Times) {
if (Times & 1) {
for (int i = 0; i < n; i++) Cur[i] = All[Cur[i]];
}
for (int i = 0; i < n; i++) tt[i] = All[All[i]];
for (int i = 0; i < n; i++) All[i] = tt[i];
Times >>= 1;
}
for (int i = 0; i < n; i++) tt[Cur[i]] = s[i];
for (int i = 0; i < n; i++) s[(i + (n - k)) % n] = tt[i];
printf("%s\n", s);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
long long n, q;
long long a[300030];
long long b[300030];
int main() {
long long t;
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld", &n, &q);
memset(b, 0, sizeof(b));
memset(a, 0, sizeof(a));
long long sum = 0;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
b[i] = a[i] - a[i - 1];
if (b[i] > 0) sum += b[i];
}
printf("%lld\n", sum);
for (long long i = 1; i <= q; i++) {
long long l, r;
scanf("%lld%lld", &l, &r);
long long c = a[l];
a[l] = a[r];
a[r] = c;
if (b[l] > 0) sum -= b[l];
if (b[l + 1] > 0) sum -= b[l + 1];
b[l] = a[l] - a[l - 1];
b[l + 1] = a[l + 1] - a[l];
if (b[l] > 0) sum += b[l];
if (b[l + 1] > 0) sum += b[l + 1];
if (b[r] > 0) sum -= b[r];
if (b[r + 1] > 0) sum -= b[r + 1];
b[r] = a[r] - a[r - 1];
b[r + 1] = a[r + 1] - a[r];
if (b[r] > 0) sum += b[r];
if (b[r + 1] > 0) sum += b[r + 1];
printf("%lld\n", sum);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int UNDEF = -1;
const int INF = 2000000000;
const long long INF64 = 4000000000000000000;
const double PI = 3.1415926535897932384626433832795;
const double EPS = 1e-12;
template <typename T>
T sqr(const T &x) {
return x * x;
}
template <typename T>
const string GetString(const T &val) {
ostringstream sout;
sout << val;
return sout.str();
}
namespace Ololo {
double x1, y1, r1;
double x2, y2, r2;
double xx1, yy1;
double FindMin(double a, double b, double (*F)(double)) {
while (fabs(a - b) >= EPS) {
double l = a + (b - a) / 3.0;
double r = b - (b - a) / 3.0;
if (F(l) > F(r))
a = l;
else
b = r;
}
return (a + b) / 2.0;
}
double F2(double alpha) {
double xx2 = x2 + r2 * cos(alpha);
double yy2 = y2 + r2 * sin(alpha);
return sqrt(sqr(xx1 - xx2) + sqr(yy1 - yy2));
}
double F1(double phi) {
xx1 = x1 + r1 * cos(phi);
yy1 = y1 + r1 * sin(phi);
double alpha = FindMin(0, 2 * PI, F2);
double xx2 = x2 + r2 * cos(alpha);
double yy2 = y2 + r2 * sin(alpha);
return sqrt(sqr(xx1 - xx2) + sqr(yy1 - yy2));
}
void Solve() {
cin >> x1 >> y1 >> r1;
cin >> x2 >> y2 >> r2;
double phi = FindMin(0, 2 * PI, F1);
xx1 = x1 + r1 * cos(phi);
yy1 = y1 + r1 * sin(phi);
double alpha = FindMin(0, 2 * PI, F2);
double xx2 = x2 + r2 * cos(alpha);
double yy2 = y2 + r2 * sin(alpha);
double r = sqrt(sqr(xx1 - xx2) + sqr(yy1 - yy2)) / 2.0;
printf("%.15f\n", r);
}
} // namespace Ololo
int main() {
Ololo::Solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int n, a[N], b[N];
int id[N], vis[N];
long long v[N];
priority_queue<pair<long long, long long> > Q;
bool cmp(int x, int y) { return v[x] == v[y] ? x > y : v[x] < v[y]; }
bool check(int T) {
for (; !Q.empty(); Q.pop())
;
for (int i = (int)(1); i <= (int)(2 * n); i++) id[i] = i, vis[i] = 0;
for (int i = (int)(1); i <= (int)(2 * n); i++) v[i] = b[i];
sort(id + 1, id + 2 * n + 1, cmp);
for (int i = (int)(1); i <= (int)(2 * n); i++) {
Q.push(pair<long long, long long>(1ll * T * a[id[i]] + b[id[i]], i));
if (id[i] <= n) vis[id[Q.top().second]]++;
}
for (int i = (int)(1); i <= (int)(2 * n); i++) v[i] = 1ll * a[i] * T + b[i];
sort(id + 1, id + 2 * n + 1, cmp);
int cnt = 0;
for (int i = (int)(1); i <= (int)(2 * n); i++) {
if (id[i] > n) cnt--;
cnt += vis[id[i]];
if (cnt > 0) return 0;
}
return 1;
}
struct edge {
int from, to, next, f, v;
} e[N * 50];
int head[N * 6], tot = 1;
void add(int x, int y, int f, int v) {
e[++tot] = (edge){x, y, head[x], f, v};
head[x] = tot;
e[++tot] = (edge){y, x, head[y], 0, -v};
head[y] = tot;
}
int q[N * 100], Vis[N * 6];
int dis[N * 6], from[N * 6];
int S, T, flow, cost, times;
bool bfs() {
for (int i = (int)(1); i <= (int)(T); i++) dis[i] = (1 << 30), Vis[i] = 0;
int h = 0, t = 1;
q[1] = S;
dis[S] = 0;
while (h != t) {
int x = q[++h];
Vis[x] = 0;
for (int i = head[x]; i; i = e[i].next)
if (dis[e[i].to] > dis[x] + e[i].v && e[i].f) {
dis[e[i].to] = dis[x] + e[i].v;
from[e[i].to] = i;
if (!Vis[e[i].to]) {
Vis[e[i].to] = 1;
q[++t] = e[i].to;
}
}
}
return dis[T] != (1 << 30);
}
void del() {
flow++;
cost += dis[T];
for (int i = from[T]; i; i = from[e[i].from]) e[i].f--, e[i ^ 1].f++;
}
int getT(int t) {
S = 6 * n + 1;
T = S + 1;
for (int i = (int)(1); i <= (int)(n); i++) {
add(S, i + 0 * n, 1, 0);
add(i + 0 * n, i + 1 * n, 1, 1);
add(i + 0 * n, i + 3 * n, 1 << 20, 0);
add(i + 1 * n, i + 3 * n, 1 << 20, 0);
add(i + 2 * n, i + 4 * n, 1 << 20, 0);
add(i + 2 * n, i + 5 * n, 1 << 20, 0);
add(i + 4 * n, i + 5 * n, 1, 1);
add(i + 5 * n, T, 1, 0);
}
for (int i = (int)(1); i <= (int)(2 * n); i++) id[i] = i;
for (int i = (int)(1); i <= (int)(2 * n); i++) v[i] = b[i];
sort(id + 1, id + 2 * n + 1, cmp);
for (int i = (int)(2 * n); i >= (int)(2); i--) {
add(id[i] + 1 * n, id[i - 1] + 1 * n, 1 << 20, 0);
if (v[id[i]] == v[id[i - 1]])
add(id[i - 1] + 1 * n, id[i] + 1 * n, 1 << 20, 0);
}
for (int i = (int)(1); i <= (int)(2 * n); i++) v[i] = 1ll * a[i] * t + b[i];
sort(id + 1, id + 2 * n + 1, cmp);
for (int i = (int)(2 * n); i >= (int)(2); i--) {
add(id[i] + 3 * n, id[i - 1] + 3 * n, 1 << 20, 0);
if (v[id[i]] == v[id[i - 1]])
add(id[i - 1] + 3 * n, id[i] + 3 * n, 1 << 20, 0);
}
flow = cost = 0;
for (; bfs(); del())
;
return cost;
}
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(2 * n); i++) scanf("%d%d", &a[i], &b[i]);
int l = 0, r = 1e9, ans = r + 1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
if (ans == 1e9 + 1)
puts("-1");
else
printf("%d %d\n", ans, getT(ans));
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int t, h;
int x, y;
int a = INT_MIN, b = INT_MIN, c = INT_MIN, d = INT_MIN;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &x, &y);
a = max(a, x + y);
b = max(b, x - y);
c = max(c, -x + y);
d = max(d, -x - y);
}
scanf("%d", &h);
int ans = INT_MAX;
int p;
for (int i = 1; i <= h; i++) {
scanf("%d%d", &x, &y);
if (ans > max(max(-x - y + a, -x + y + b), max(x - y + c, x + y + d))) {
ans = max(max(-x - y + a, -x + y + b), max(x - y + c, x + y + d));
p = i;
}
}
printf("%d\n%d\n", ans, p);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long n, x, cnt[500000], mint, dem[500000], q[500000], first, last, dis[500000];
long vs[5000000];
void BFS(long i, long x) {
long u, v;
vs[x] = i;
first = 1;
last = 1;
q[1] = x;
dis[x] = 0;
while (first <= last) {
u = q[first];
cnt[u] += dis[u];
dem[u] += 1;
first += 1;
v = u << 1;
if (v <= 100000 && vs[v] != i) {
vs[v] = i;
dis[v] = dis[u] + 1;
last += 1;
q[last] = v;
}
v = u >> 1;
if (vs[v] != i) {
vs[v] = i;
dis[v] = dis[u] + 1;
last += 1;
q[last] = v;
}
}
return;
}
int main() {
memset(cnt, 0, sizeof(cnt));
memset(dem, 0, sizeof(dem));
memset(vs, 0, sizeof(vs));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
BFS(i, x);
}
mint = 1000000000;
for (int i = 1; i <= 100000; i++)
if (dem[i] == n)
if (cnt[i] < mint) mint = cnt[i];
cout << mint;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void logf(istream_iterator<string> it) {}
template <typename T, typename... Args>
void logf(istream_iterator<string> it, T a, Args... args) {
cout << *it << "=" << a << " ";
logf(++it, args...);
}
const double PI = acos(-1);
void solve() {
int n;
cin >> n;
;
int a;
cin >> a;
;
int b;
cin >> b;
;
a--;
b--;
int cnt = 1;
string sa, sb;
while ((1 << cnt) <= n) {
if (a & (1 << (cnt - 1)))
sa += "1";
else
sa += "0";
if (b & (1 << (cnt - 1)))
sb += "1";
else
sb += "0";
cnt++;
}
cnt--;
reverse(sa.begin(), sa.end());
reverse(sb.begin(), sb.end());
int ans = 0;
for (int i = 0; i < cnt; i++) {
if (sa[i] != sb[i])
break;
else
ans++;
}
ans = cnt - ans;
if (ans == cnt)
cout << "Final!" << endl;
else
cout << ans << endl;
}
int main() {
cin.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long num(long long n) {
long long s = 0, t, m = 0;
while (n) {
t = n % 10;
if (t > 0) s = s * 10 + t;
n = n / 10;
}
while (s) {
t = s % 10;
m = m * 10 + t;
s = s / 10;
}
return m;
}
int main() {
ios_base::sync_with_stdio(0);
long long jj, tc, n, m;
while (cin >> n >> m) {
long long a, b, c;
c = n + m;
a = num(n);
b = num(m);
c = num(c);
if (a + b == c)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
void dfs(int v, bool marked[], std::vector<int> adjacency_list[]) {
marked[v] = true;
for (size_t i = 0; i < adjacency_list[v].size(); ++i) {
int to = adjacency_list[v][i];
if (!marked[to]) dfs(to, marked, adjacency_list);
}
}
int clustersCount(std::vector<int> adjacency_list[], size_t points_count) {
std::vector<int> cluster;
bool marked[100] = {0};
int clusters_count = 0;
for (size_t i = 0; i < points_count; ++i) {
if (!marked[i]) {
++clusters_count;
dfs(i, marked, adjacency_list);
}
}
return clusters_count;
}
void fillInAdjacencyList(std::vector<int> adjacency_list[],
const std::vector<int>& x, const std::vector<int>& y) {
size_t points_count = x.size();
for (size_t i = 0; i != points_count; ++i) {
for (size_t j = i + 1; j < points_count; ++j) {
if (x[i] == x[j] || y[i] == y[j]) {
adjacency_list[i].push_back(j);
adjacency_list[j].push_back(i);
}
}
}
}
int main() {
size_t points_count = 0;
scanf("%d", &points_count);
std::vector<int> point_x(points_count);
std::vector<int> point_y(points_count);
for (size_t i = 0; i != points_count; ++i) {
scanf("%d %d", &point_x[i], &point_y[i]);
}
std::vector<int> adjacency_list[100];
fillInAdjacencyList(adjacency_list, point_x, point_y);
printf("%d", clustersCount(adjacency_list, points_count) - 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
struct node {
double left, right, mid, sum;
};
node inf;
int n;
int m, c;
int x[150000], p[150000];
node tree[600000];
node un(node a, node b) {
node c;
c.left = max(a.left, a.sum + b.left);
c.mid = max(a.right + b.left, max(a.mid, b.mid));
c.right = max(b.right, a.right + b.sum);
c.sum = a.sum + b.sum;
return c;
}
node add(int x, int l, int r, int p, double q) {
if (r < p || l > p) return tree[x];
if (l == r) {
if (q > 0) tree[x].left = tree[x].mid = tree[x].right = q;
tree[x].sum = q;
return tree[x];
}
int s = (l + r) / 2;
return tree[x] =
un(add(x * 2 + 1, l, s, p, q), add(x * 2 + 2, s + 1, r, p, q));
}
node get(int x, int l, int r, int lc, int rc) {
if (r < lc || l > rc) return inf;
if (l >= lc && r <= rc) return tree[x];
int s = (l + r) / 2;
return un(get(x * 2 + 1, l, s, lc, rc), get(x * 2 + 2, s + 1, r, lc, rc));
}
int main() {
scanf("%d%d%d", &n, &m, &c);
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
for (int i = 0; i + 1 < n; i++) scanf("%d", &p[i]);
memset(tree, 0, sizeof(tree));
for (int i = 0; i + 1 < n; i++)
add(0, 0, n - 2, i, (x[i + 1] - x[i]) / 2.0 - p[i] / 100.0 * c);
double ans = 0;
inf.left = inf.right = inf.mid = inf.sum = -1e18;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b -= 2;
ans += get(0, 0, n - 2, a, b).mid;
}
printf("%.10f\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long A = 100000000000000LL, N = 228228;
long long i, j, n, m, o, a[N], x, y;
int main() {
cin >> m >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
a[y] += x;
}
for (i = 10; i >= 1; i--) o += min(m, a[i]) * i, m = max(0LL, m - a[i]);
cout << o << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class prog {
int num;
vector<long long> v, p;
public:
void ini() {
num = 0;
v.clear();
p.clear();
}
int size() { return num; }
bool add(long long x) {
num++;
if (x != -1 && v.size() < 2) {
v.push_back(x);
p.push_back(num - 1);
}
if (v.size() < 2) return true;
if ((v[1] - v[0]) % (p[1] - p[0])) return false;
long long inc = (v[1] - v[0]) / (p[1] - p[0]);
long long fir = v[0] + (0 - p[0]) * inc;
long long las = v[0] + (num - 1 - p[0]) * inc;
if (x != -1 && x != las) return false;
if (fir < 1 || las < 1) return false;
return true;
}
};
int main() {
long long n, c, ret = 0;
cin >> n;
prog p;
p.ini();
for (int i = 0; i < n; i++) {
cin >> c;
if (!p.add(c)) {
p.ini();
p.add(c);
ret++;
}
}
if (p.size() > 0) ret++;
cout << ret;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 301101;
long long n, p, d[N], w, ans, x[N], y[N];
pair<long long, long long> k;
vector<long long> a;
map<pair<long long, long long>, long long> te;
int main() {
scanf("%lld%lld", &n, &p);
for (long long i = 1; i <= n; i++) {
scanf("%lld%lld", &x[i], &y[i]);
if (x[i] < y[i]) swap(x[i], y[i]);
k.first = x[i], k.second = y[i];
te[k]++;
d[k.first]++, d[k.second]++;
}
for (long long i = 1; i <= n; i++) {
if (d[i] >= p)
w++;
else
a.push_back(d[i]);
}
ans = ((w * (w - 1)) / 2) + (w * a.size());
if (!a.size()) return cout << ans, 0;
sort(a.begin(), a.end());
for (long long i = 0; i < a.size() - 1; i++) {
long long l = i, r = a.size() - 1;
if (a[l] + a[a.size() - 1] < p) continue;
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (a[mid] + a[i] >= p)
r = mid;
else
l = mid;
}
ans += a.size() - r;
}
for (long long i = 1; i <= n; i++) {
k.first = x[i], k.second = y[i];
if (d[x[i]] + d[y[i]] >= p and d[x[i]] + d[y[i]] - te[k] < p and
d[x[i]] < p and d[y[i]] < p) {
ans--;
te[k] = 0;
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} A[10005], B[10005], CA[10005], CB[10005];
int tim, qim;
node operator+(node a, node b) { return node{a.x + b.x, a.y + b.y}; }
node operator-(node a, node b) { return node{a.x - b.x, a.y - b.y}; }
int operator*(node a, node b) { return a.x * b.x + a.y * b.y; }
int operator/(node a, node b) { return a.x * b.y - a.y * b.x; }
bool operator<(node a, node b) {
if (a.x == b.x) return a.y > b.y;
return a.x < b.x;
}
void convex_hull(node p[], node c[], int n, int &tp) {
sort(p + 1, p + n + 1);
tp = 0;
for (int i = 1; i <= n; i++) {
while (tp > 1 && (c[tp] - p[i]) / (c[tp - 1] - p[i]) >= 0) tp--;
c[++tp] = p[i];
}
int k = tp--;
for (int i = n; i >= 1; i--) {
while (tp > k && (c[tp] - p[i]) / (c[tp - 1] - p[i]) >= 0) tp--;
c[++tp] = p[i];
}
tp--;
}
bool solve(node a[], node b[], int na, int nb) {
random_shuffle(a + 1, a + na + 1);
random_shuffle(b + 1, b + nb + 1);
for (int i = 1; i <= na; i++)
for (int j = i + 1, k; j <= na; j++) {
node pa = a[i], pb = a[j];
double lp = -1e100, rp = 1e100, inf = 1e100;
for (k = 1; k <= na; k++) {
if (k == i) continue;
if (k == j) continue;
int ta = (a[k] - pa) * (a[k] - pb);
int tb = (pa - a[k]) / (pa - pb);
assert(tb != 0);
if (tb == 0) {
if (ta > 0)
break;
else
continue;
}
double r = (double)ta / tb;
if (tb < 0)
rp = min(rp, r);
else if (tb > 0)
lp = max(lp, r);
if (lp > rp) break;
}
if (k <= na || lp > rp) continue;
for (k = 1; k <= nb; k++) {
int ta = (b[k] - pa) * (b[k] - pb);
int tb = (pa - b[k]) / (pa - pb);
if (tb == 0) {
if (ta <= 0)
break;
else
continue;
}
double r = (double)ta / tb;
if (tb > 0)
rp = min(rp, r);
else if (tb < 0)
lp = max(lp, r);
if (lp >= rp) break;
}
if (k > nb && lp < rp) return 1;
}
return 0;
}
int main() {
srand(time(NULL));
clock_t st, ed;
double totaltime;
st = clock();
int n, m, cn, cm, i;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d%d", &A[i].x, &A[i].y);
for (i = 1; i <= m; i++) scanf("%d%d", &B[i].x, &B[i].y);
if (n == 1 || m == 1) return puts("YES"), 0;
convex_hull(A, CA, n, cn);
convex_hull(B, CB, m, cm);
if (solve(CA, B, cn, m) || solve(CB, A, cm, n))
puts("YES");
else
puts("NO");
ed = clock();
totaltime = (double)(ed - st) / CLOCKS_PER_SEC;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkMax(T &x, T y) {
if (y > x) x = y;
}
template <typename T>
void chkMin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void inline read(T &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s <= '9' && s >= '0') x = x * 10 + (s ^ 48), s = getchar();
x *= f;
}
template <typename T>
void print(T x) {
if (x < 0) {
putchar('-');
print(-x);
return;
}
if (x >= 10) print(x / 10);
putchar((x % 10) + '0');
}
const int N = 1005;
int n, m, a[N][N], t, L1[N][N], L2[N][N], S1[N], S2[N];
pair<int, int> e[N];
int main() {
read(n), read(m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) read(a[i][j]);
for (int i = 1; i <= n; i++) {
t = 0;
for (int j = 1; j <= m; j++) e[++t] = make_pair(a[i][j], j);
sort(e + 1, e + 1 + t);
int c = 0;
for (int j = 1; j <= t; j++) {
if (j == 1 || e[j].first != e[j - 1].first) c++;
L1[i][e[j].second] = c;
}
S1[i] = c;
}
for (int j = 1; j <= m; j++) {
t = 0;
for (int i = 1; i <= n; i++) e[++t] = make_pair(a[i][j], i);
sort(e + 1, e + 1 + t);
int c = 0;
for (int i = 1; i <= n; i++) {
if (i == 1 || e[i].first != e[i - 1].first) c++;
L2[e[i].second][j] = c;
}
S2[j] = c;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", 1 + max(L1[i][j] - 1, L2[i][j] - 1) +
max(S1[i] - L1[i][j], S2[j] - L2[i][j]));
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long double pi = acos(-1);
void solve() {
int a, b, c;
cin >> a >> b >> c;
int m;
cin >> m;
vector<pair<int, int> > mouse(m);
for (long long int i = 0; i < m; i++) {
int num;
string s;
cin >> num >> s;
mouse[i].first = num;
if (s[0] == 'U')
mouse[i].second = 0;
else
mouse[i].second = 1;
}
sort(mouse.begin(), mouse.end());
long long int count = 0, cost = 0;
for (long long int i = 0; i < m; i++) {
if (mouse[i].second == 1 && b > 0) {
b--;
count++;
cost += mouse[i].first;
} else if (mouse[i].second == 0 && a > 0) {
a--;
count++;
cost += mouse[i].first;
} else if (c > 0) {
c--;
count++;
cost += mouse[i].first;
}
}
cout << count << " " << cost;
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TC = 1, t = 0;
while (t++ < TC) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int ans[maxn];
struct Record {
int l, v, r, id;
} a[maxn], b[maxn];
struct Tree {
int l, r, chg, opt;
Tree *lc, *rc;
Tree(int _l, int _r) : l(_l), r(_r) {
chg = opt = 0;
lc = l + 1 < r ? new Tree(l, (l + r) >> 1) : NULL;
rc = l + 1 < r ? new Tree((l + r) >> 1, r) : NULL;
}
void down() {
lc->chg += chg;
lc->opt += chg;
rc->chg += chg;
rc->opt += chg;
chg = 0;
}
int query(int ll, int rr) {
if (ll <= l && rr >= r) return opt;
if (chg) down();
int res = 0;
if (ll < (l + r) >> 1) res = max(res, lc->query(ll, rr));
if (rr > (l + r) >> 1) res = max(res, rc->query(ll, rr));
opt = max(lc->opt, rc->opt);
return res;
}
void change(int ll, int rr, int x) {
if (ll <= l && rr >= r) {
chg += x;
opt += x;
return;
}
down();
if (ll < (l + r) >> 1) lc->change(ll, rr, x);
if (rr > (l + r) >> 1) rc->change(ll, rr, x);
opt = max(lc->opt, rc->opt);
}
void clear() {
chg = opt = 0;
if (lc != NULL) lc->clear();
if (rc != NULL) rc->clear();
}
int which(int ll, int rr, int x) {
if (l + 1 == r) return l + 1;
if (chg) down();
if (ll < (l + r) >> 1 && lc->query(ll, rr) == x)
return lc->which(ll, rr, x);
return rc->which(ll, rr, x);
}
} * root;
bool cmp_l(Record u, Record v) { return u.l < v.l; }
bool cmp_v(Record u, Record v) { return u.v < v.v; }
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].l >> a[i].v >> a[i].r;
a[i].id = i;
b[i] = a[i];
}
sort(a, a + n, cmp_l);
sort(b, b + n, cmp_v);
root = new Tree(0, 300000);
int res = 0;
for (int i = 0, k = 0; i < n; i++) {
for (; k < n && b[k].v < a[i].l; k++) root->change(b[k].v - 1, b[k].r, -1);
root->change(a[i].v - 1, a[i].r, 1);
res = max(res, root->query(a[i].l - 1, 300000));
}
root->clear();
for (int i = 0, k = 0; i < n; i++) {
for (; k < n && b[k].v < a[i].l; k++) root->change(b[k].v - 1, b[k].r, -1);
root->change(a[i].v - 1, a[i].r, 1);
if (res == root->query(a[i].l - 1, 300000)) {
int whi = root->which(a[i].l - 1, 300000, res);
memset(ans, 0, sizeof(ans));
for (int j = 0; j <= i; j++)
if (a[j].v <= whi && a[j].r >= whi && a[j].v >= a[i].l)
ans[a[j].id] = 1;
cout << res << endl;
for (int j = 0; j < n; j++)
if (ans[j]) cout << j + 1 << ' ';
cout << endl;
break;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3e5 + 5;
int n, q, deg[mxN], dp[mxN][2];
vector<int> adj[mxN];
void dfs(int u, int p) {
dp[u][1] = deg[u] - 1;
vector<int> d;
for (int v : adj[u]) {
if (v == p) continue;
dfs(v, u);
dp[u][0] = max(dp[u][0], dp[v][0]);
if (adj[v].size() > 1) {
d.push_back(dp[v][1]);
dp[u][1] = max(dp[u][1], deg[u] + dp[v][1] - 1);
}
}
sort(d.rbegin(), d.rend());
int x = deg[u] + 1;
for (int i = 0; i < 2; i++) {
if (i < d.size()) x += d[i];
}
dp[u][0] = max(dp[u][0], x);
}
int main() {
cin >> q;
while (q--) {
for (int i = 0; i <= n; i++) {
adj[i].clear();
deg[i] = 0;
dp[i][0] = dp[i][1] = 0;
}
cin >> n;
int x, y;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
deg[i] = adj[i].size();
}
dfs(1, 1);
cout << dp[1][0] << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 + 100;
vector<int> ans[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, col = 10000;
cin >> n >> m;
for (int i = (int)0; i < (int)m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
ans[u].push_back(col);
ans[v].push_back(col);
--col;
}
for (int i = (int)0; i < (int)n; ++i) {
ans[i].push_back(1 + i);
cout << ans[i].size() << '\n';
for (auto x : ans[i]) {
cout << 1 + i << " " << x << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct Emp {
int cost, t, get, ind;
} Emp;
bool operator<(const Emp &a, const Emp &b) { return a.t < b.t; }
bool active[1440];
int activetimebefore[1441];
int activetimeperday;
int convert(int d, int t) {
return (d - 1) * activetimeperday + activetimebefore[t];
}
void printt(int t) {
int d = t / activetimeperday + 1;
t %= activetimeperday;
printf("%d ", d);
int tt = 0;
while (!active[tt]) ++tt;
for (int i = (0); i < (t); ++i) {
++tt;
while (!active[tt]) ++tt;
}
printf("%02d:%02d", tt / 60, tt % 60);
}
typedef struct X {
int t, at, have;
} X;
bool operator<(const X &a, const X &b) {
if (a.at != b.at) return a.at > b.at;
if (a.t != b.t) return a.t > b.t;
}
void run() {
int nsubj, nemp, ndays;
scanf("%d%d%d", &nsubj, &nemp, &ndays);
vector<string> subj(nsubj);
for (int i = (0); i < (nsubj); ++i) cin >> subj[i];
vector<int> costsubj(nsubj);
for (int i = (0); i < (nsubj); ++i) scanf("%d", &costsubj[i]);
memset(active, true, sizeof(active));
for (int i = (0); i < (4); ++i) {
int h1, m1, h2, m2;
scanf("%d:%d-%d:%d", &h1, &m1, &h2, &m2);
int t1 = h1 * 60 + m1, t2 = h2 * 60 + m2;
int t = t1;
while (true) {
active[t] = false;
if (t == t2) break;
if (++t >= 1440) t = 0;
}
}
activetimebefore[0] = 0;
for (int i = (0); i < (1440); ++i)
activetimebefore[i + 1] = activetimebefore[i] + (active[i] ? 1 : 0);
activetimeperday = activetimebefore[1440];
vector<Emp> emp;
for (int i = (0); i < (nemp); ++i) {
string s;
cin >> s;
int d, h, m, get;
scanf("%d %d:%d %d", &d, &h, &m, &get);
int t = h * 60 + m;
int cost = -1;
for (int j = (0); j < (nsubj); ++j)
if (subj[j] == s) {
cost = costsubj[j];
break;
}
if (cost == -1) continue;
emp.push_back((Emp){cost, convert(d, t), get, i + 1});
}
sort(emp.begin(), emp.end());
vector<vector<int> > best(ndays * activetimeperday + 1,
vector<int>(nemp + 1, -1));
vector<vector<int> > prevt(ndays * activetimeperday + 1,
vector<int>(nemp + 1, -1));
{
if (0 <= ndays * activetimeperday && 0 > best[0][0]) {
best[0][0] = 0, prevt[0][0] = -1;
}
};
int maxhave = 0, endat = -1, endt = -1;
for (int at = (0); at <= (((int)(emp).size())); ++at)
for (int t = (0); t <= (ndays * activetimeperday); ++t) {
int have = best[t][at];
if (have == -1) continue;
if (at >= ((int)(emp).size())) {
if (have > maxhave) maxhave = have, endat = at, endt = t;
continue;
}
{
if (t <= ndays * activetimeperday && have > best[t][at + 1]) {
best[t][at + 1] = have, prevt[t][at + 1] = t;
}
};
if (t + emp[at].cost <= emp[at].t) {
if (t + emp[at].cost <= ndays * activetimeperday &&
have + emp[at].get > best[t + emp[at].cost][at + 1]) {
best[t + emp[at].cost][at + 1] = have + emp[at].get,
prevt[t + emp[at].cost][at + 1] = t;
}
};
}
vector<pair<int, int> > res;
for (int t = endt, at = endat; at > 0; t = prevt[t][at], --at) {
if (prevt[t][at] != t) res.push_back(make_pair(at - 1, prevt[t][at]));
}
reverse(res.begin(), res.end());
printf("%d\n", maxhave);
printf("%d\n", ((int)(res).size()));
for (int i = (0); i < (((int)(res).size())); ++i) {
printf("%d ", emp[res[i].first].ind);
printt(res[i].second);
printf(" ");
printt(res[i].second + emp[res[i].first].cost - 1);
puts("");
}
}
int main() {
run();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, d[200 + 5], nows[200 + 5], fr[200 + 5], en[200 + 5],
A[200 + 5], S, T, fa[200 + 5], now, Bh, Ch, B[200 + 5], C[200 + 5], H, un,
wn, ToT;
struct yyy {
int to, w, z;
} tmp;
struct ljb {
int head, h[200 + 5];
yyy f[1000 + 5 << 2];
inline void add(int x, int y, int z) {
f[head] = (yyy){y, z, h[x]};
h[x] = head++;
}
} s, G;
queue<int> Q;
struct ques {
int x, y, z;
} F[200 + 5];
inline bool cmp(ques x, ques y) { return x.z > y.z; }
inline void Get(int x, int y, int z) {
s.add(x, y, z);
s.add(y, x, z);
}
inline int bfs() {
while (!Q.empty()) Q.pop();
memset(d, 0x3f, sizeof(d));
d[S] = 0;
Q.push(S);
nows[S] = s.h[S];
while (!Q.empty()) {
now = Q.front();
Q.pop();
for (int i = s.h[now]; ~i; i = tmp.z) {
tmp = s.f[i];
if (!tmp.w || d[tmp.to] < 1e9) continue;
d[tmp.to] = d[now] + 1;
Q.push(tmp.to);
nows[tmp.to] = s.h[tmp.to];
if (tmp.to == T) return 1;
}
}
return 0;
}
inline int dfs(int x, int sum) {
if (x == T) return sum;
int i, k, pus = 0;
yyy tmp;
for (i = nows[x]; ~i; i = tmp.z) {
tmp = s.f[i];
nows[x] = i;
if (!tmp.w || d[tmp.to] != d[x] + 1) continue;
k = dfs(tmp.to, ((sum) < (tmp.w) ? (sum) : (tmp.w)));
if (!k) d[tmp.to] = 1e9;
pus += k;
sum -= k;
s.f[i].w -= k;
s.f[i ^ 1].w += k;
if (!sum) break;
}
return pus;
}
inline void build(int l, int r) {
if (l == r) return;
int Ans = 0, i;
S = A[l];
T = A[r];
s = G;
while (bfs()) Ans += dfs(S, 1e9);
F[++H] = (ques){S, T, Ans};
ToT += Ans;
Bh = Ch = 0;
for (i = l; i <= r; i++) (d[A[i]] < 1e9 ? B[++Bh] : C[++Ch]) = A[i];
for (i = l; i <= l + Bh - 1; i++) A[i] = B[i - l + 1];
for (i = l + Bh; i <= r; i++) A[i] = C[i - l - Bh + 1];
Ans = Bh;
build(l, l + Ans - 1);
build(l + Ans, r);
}
inline int Getfa(int x) { return x == fa[x] ? x : fa[x] = Getfa(fa[x]); }
int main() {
register int i;
scanf("%d%d", &n, &m);
memset(s.h, -1, sizeof(s.h));
for (i = 1; i <= m; i++) scanf("%d%d%d", &x, &y, &z), Get(x, y, z);
for (i = 1; i <= n; i++) A[i] = i;
G = s;
build(1, n);
sort(F + 1, F + n, cmp);
for (i = 1; i <= n; i++) fa[i] = en[i] = fr[i] = i;
for (i = 1; i < n; i++)
un = Getfa(F[i].x), wn = Getfa(F[i].y), en[un] = fr[wn], fr[wn] = fr[un],
fa[un] = wn;
now = fr[Getfa(1)];
printf("%d\n", ToT);
while (en[now] ^ now) printf("%d ", now), now = en[now];
printf("%d\n", now);
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
const long long maxn = 3e5 + 1, mod = 998244353;
using namespace std;
long long G, N, M;
vector<vector<long long> > v[102];
vector<long long> g[51];
long long dp[102][51][51];
struct trie {
short next[2] = {-1, -1};
short go[2] = {-1, -1};
short link = -1;
short p = -1;
bool pc = 0, trm = 0;
trie() {}
};
trie t[51];
long long mx = 0;
void add_string(long long ci) {
long long x = 0;
for (long long i = 0; i < g[ci].size(); i++) {
if (t[x].next[g[ci][i]] == -1) t[x].next[g[ci][i]] = ++mx;
t[t[x].next[g[ci][i]]].p = x;
t[t[x].next[g[ci][i]]].pc = g[ci][i];
x = t[x].next[g[ci][i]];
}
t[x].trm = 1;
}
extern long long slink(long long x);
long long go(long long x, long long st) {
if (t[x].go[st] != -1) return t[x].go[st];
if (t[x].next[st] != -1) {
t[x].go[st] = t[x].next[st];
return t[x].go[st];
}
if (x == 0) return (t[x].go[st] = 0);
return (t[x].go[st] = go(slink(x), st));
}
long long slink(long long x) {
if (t[x].link != -1) return t[x].link;
if (x == 0 || t[x].p == 0) return (t[x].link = 0);
return (t[x].link = go(slink(t[x].p), t[x].pc));
}
long long gmin(long long x, long long y) {
if (x == -1) return y;
if (y == -1) return x;
return min(x, y);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> G >> N >> M;
for (long long i = 0; i < N; i++) {
long long a, k;
cin >> a >> k;
v[a].push_back(vector<long long>(k, 0));
for (long long j = 0; j < k; j++) cin >> v[a].back()[j];
}
for (long long i = 0; i < M; i++) {
long long first;
cin >> first;
g[i].resize(first);
for (long long j = 0; j < first; j++) cin >> g[i][j];
add_string(i);
}
for (long long i = 0; i < G; i++)
for (long long j = 0; j <= mx; j++)
for (long long first = 0; first <= mx; first++) dp[i][j][first] = -1;
for (long long i = 0; i <= mx; i++) {
for (long long x = i; x != 0; x = slink(x))
if (t[x].trm) {
t[i].trm = 1;
break;
}
}
for (long long i = 0; i <= mx; i++) {
if (t[i].trm) continue;
long long g0 = go(i, 0), g1 = go(i, 1);
if (!t[g0].trm) dp[0][i][g0] = 1;
if (!t[g1].trm) dp[1][i][g1] = 1;
}
for (long long cntr = 0; cntr < G; cntr++) {
for (long long i = 2; i < G; i++) {
for (auto cv : v[i]) {
long long cd[mx + 1][mx + 1];
for (long long x = 0; x <= mx; x++)
for (long long y = 0; y <= mx; y++) cd[x][y] = -1;
for (long long x = 0; x <= mx; x++) {
if (t[x].trm) continue;
for (long long y = 0; y <= mx; y++) cd[x][y] = dp[cv[0]][x][y];
for (long long j = 1; j < cv.size(); j++) {
long long pv[mx + 1];
for (long long z = 0; z <= mx; z++) pv[z] = -1;
for (long long y = 0; y <= mx; y++)
for (long long z = 0; z <= mx; z++) {
if (cd[x][y] == -1 || dp[cv[j]][y][z] == -1) continue;
pv[z] = gmin(pv[z], cd[x][y] + dp[cv[j]][y][z]);
}
for (long long z = 0; z <= mx; z++) cd[x][z] = pv[z];
}
}
for (long long x = 0; x <= mx; x++)
for (long long y = 0; y <= mx; y++)
dp[i][x][y] = gmin(dp[i][x][y], cd[x][y]);
}
}
}
for (long long i = 2; i < G; i++) {
long long can = -1;
for (long long j = 0; j <= mx; j++) can = gmin(can, dp[i][0][j]);
if (can == -1)
cout << "YES";
else
cout << "NO " << can;
cout << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > s1, s2, p2;
int delta1 = 0, delta2 = 0;
void ispisi() {
set<pair<int, int> >::iterator it;
printf("S1 delta: %i, sadrzi:\n", delta1);
for (it = s1.begin(); it != s1.end(); it++) {
printf("%i %i\n", (*it).first, (*it).second);
}
printf("S2 delta: %i, sadrzi:\n", delta2);
for (it = s2.begin(); it != s2.end(); it++) {
printf("%i %i\n", (*it).first, (*it).second);
}
printf("P2 sadrzi:\n");
for (it = p2.begin(); it != p2.end(); it++) {
printf("%i %i\n", (*it).first, (*it).second);
}
}
int main() {
int n;
scanf("%i", &n);
vector<int> poz(n + 1);
for (int i = 0; i < n; i++) {
int a;
scanf("%i", &a);
poz[a] = i;
}
for (int i = 0; i < n; i++) {
int a;
scanf("%i", &a);
if (i >= poz[a]) {
s1.insert({i - poz[a], a});
} else {
s2.insert({poz[a] - i, a});
p2.insert({i, a});
}
}
printf("%i\n",
min((*s1.begin()).first - delta1, (*s2.begin()).first + delta2));
for (int i = 1; i < n; i++) {
delta1--;
delta2++;
while (s1.size() > 0 && (*s1.begin()).first + delta1 < 0) {
int a = (*s1.begin()).second;
s2.insert({1 - delta2, a});
p2.insert({poz[a] - 1 - delta1, a});
s1.erase(s1.begin());
}
while (p2.size() > 0 && (*p2.begin()).first + delta1 < 0) {
int a = (*p2.begin()).second;
s2.erase(s2.find({-(*p2.begin()).first + poz[a], a}));
s1.insert({n - 1 - poz[a] - delta1, a});
p2.erase(p2.begin());
}
printf("%i\n",
min((*s1.begin()).first + delta1, (*s2.begin()).first + delta2));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long fact[20];
map<long long, long long> m[40];
long long ans = 0, s;
int n, k, a[30];
void calc() {
long long i;
fact[0] = 1;
fact[1] = 1;
for (i = 2; i <= 18; i++) fact[i] = i * fact[i - 1];
}
void meet1(int id, int sel, long long sum) {
if (sel > k) return;
if (sum > s) return;
if (id == (n / 2)) {
m[sel][sum]++;
return;
}
meet1(id + 1, sel, sum);
meet1(id + 1, sel, sum + a[id]);
if (a[id] <= 18) meet1(id + 1, sel + 1, sum + fact[a[id]]);
}
void meet2(int id, int sel, long long sum) {
if (sel > k) return;
if (sum > s) return;
if (id == n) {
for (int i = 0; i <= (k - sel); i++)
if (m[i].count(s - sum) > 0) {
ans += m[i][s - sum];
}
return;
}
meet2(id + 1, sel, sum);
meet2(id + 1, sel, sum + a[id]);
if (a[id] <= 18) meet2(id + 1, sel + 1, sum + fact[a[id]]);
}
int main() {
calc();
cin >> n >> k >> s;
int i;
for (i = 0; i < n; i++) cin >> a[i];
meet1(0, 0, 0);
meet2((n / 2), 0, 0);
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, cou, num;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> num;
if (num <= 5 - k) cou++;
}
cout << cou / 3;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char field[101][101];
bool check[101][101];
vector<pair<pair<int, int>, int> > res;
int n, m;
void spread(int x, int y) {
int sz = 0;
pair<int, int> l, r, u, d;
l = r = u = d = pair<int, int>(x, y);
while (1) {
sz++;
bool fl1, fl2, fl3, fl4;
fl1 = fl2 = fl3 = fl4 = false;
if (field[l.first][l.second - 1] == '*' && (l.second - 1) >= 1) {
l.second -= 1;
fl1 = true;
}
if (field[r.first][r.second + 1] == '*' && (r.second + 1) <= m) {
r.second += 1;
fl2 = true;
}
if (field[u.first - 1][u.second] == '*' && (u.first - 1) >= 1) {
u.first -= 1;
fl3 = true;
}
if (field[d.first + 1][d.second] == '*' && (d.first + 1) <= n) {
d.first += 1;
fl4 = true;
}
if (fl1 && fl2 && fl3 && fl4) {
check[x][y] = true;
check[l.first][l.second] = true;
check[r.first][r.second] = true;
check[u.first][u.second] = true;
check[d.first][d.second] = true;
continue;
}
sz--;
if (sz) res.push_back(pair<pair<int, int>, int>(pair<int, int>(x, y), sz));
return;
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> field[i][j];
check[i][j] = false;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (field[i][j] == '*') spread(i, j);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (field[i][j] == '*' && !check[i][j]) {
cout << -1;
return 0;
}
cout << res.size() << '\n';
for (int i = 0; i < res.size(); i++)
cout << res[i].first.first << ' ' << res[i].first.second << ' '
<< res[i].second << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long quick(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main() {
long long a, b;
int n;
scanf("%d", &n);
long long y, z;
y = quick(27, n);
z = quick(7, n);
printf("%lld", (y + mod - z) % mod);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
char dp[105][105];
int tmp[105];
int tmp2[105];
int data[105];
int trgt[105];
bool goTmp(int tails, int hds) {
for (int i = 0; i < (N); i++) tmp[i] = i + 1;
for (int i = 0; i < (hds); i++) {
for (int i = 0; i < (N); i++) tmp2[data[i] - 1] = tmp[i];
copy(tmp2, tmp2 + N, tmp);
}
for (int i = 0; i < (tails); i++) {
for (int i = 0; i < (N); i++) tmp2[i] = tmp[data[i] - 1];
copy(tmp2, tmp2 + N, tmp);
}
return equal(tmp, tmp + N, trgt);
}
bool slv(int idx, int heads) {
char &nw = dp[idx][heads];
if (nw != '?') return nw;
bool tst = goTmp(idx - heads, heads);
if (idx == K) {
return nw = tst;
}
if (tst) return nw = false;
return nw = slv(idx + 1, heads) || slv(idx + 1, heads + 1);
}
int main() {
cin >> N >> K;
for (int i = 0; i < (N); i++) cin >> data[i];
for (int i = 0; i < (N); i++) cin >> trgt[i];
memset(dp, '?', sizeof dp);
if (slv(0, 0))
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535;
long long powi(long long base, int p) {
long long res = 1;
while (p--) res *= base;
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
bool is_vowel(char c) {
c = tolower(c);
return c == 'a' || c == 'e' || c == 'o' || c == 'i' || c == 'u' || c == 'y';
}
int dist[1001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
char c;
map<int, int> dict;
for (int i = 0; i < n; i++) {
int gx, sx;
for (int j = 0; j < m; j++) {
cin >> c;
if (c == 'G') gx = j;
if (c == 'S') sx = j;
}
dist[i] = sx - gx;
if (dist[i] < 0) {
cout << -1;
return 0;
}
dict[dist[i]] = 1;
}
cout << dict.size();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-10;
int in() {
int r = 0, c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') return -in();
for (; c > 32; r = (r << 1) + (r << 3) + c - '0', c = getchar())
;
return r;
}
int mat[2100][2100];
int vis[2100][2100];
bool issqr(int x) {
int r = sqrt(x);
r--;
if (r * r == x) return true;
r++;
if (r * r == x) return true;
r++;
if (r * r == x) return true;
return false;
}
void solve() {
int n = in();
int i, j;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) mat[i][j] = in();
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) vis[i][j] = 0;
int cant;
int squares = 0;
int circles = 0;
pair<int, int> act;
int mini, minj, maxi, maxj;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (mat[i][j] == 1 && !vis[i][j]) {
cant = 0;
queue<pair<int, int> > cola;
cola.push(pair<int, int>(i, j));
vis[i][j] = 1;
maxi = i;
mini = i;
maxj = j;
minj = j;
while (!cola.empty()) {
act = cola.front();
cola.pop();
cant++;
maxi = max(maxi, act.first);
mini = min(mini, act.first);
maxj = max(maxj, act.second);
minj = min(minj, act.second);
if (mat[act.first + 1][act.second] != 0 &&
!vis[act.first + 1][act.second]) {
vis[act.first + 1][act.second] = 1;
cola.push(pair<int, int>(act.first + 1, act.second));
}
if (mat[act.first - 1][act.second] != 0 &&
!vis[act.first - 1][act.second]) {
vis[act.first - 1][act.second] = 1;
cola.push(pair<int, int>(act.first - 1, act.second));
}
if (mat[act.first][act.second + 1] != 0 &&
!vis[act.first][act.second + 1]) {
vis[act.first][act.second + 1] = 1;
cola.push(pair<int, int>(act.first, act.second + 1));
}
if (mat[act.first][act.second - 1] != 0 &&
!vis[act.first][act.second - 1]) {
vis[act.first][act.second - 1] = 1;
cola.push(pair<int, int>(act.first, act.second - 1));
}
}
if (cant == (maxj - minj + 1) * (maxi - mini + 1))
squares++;
else
circles++;
}
cout << circles << " " << squares << endl;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int towers[5010];
for (int i = 1; i <= N; i++) {
cin >> towers[i];
}
int sum = 0, t[5010], k[5010];
t[0] = 0;
k[0] = 0;
for (int i = 1; i <= N; i++) {
sum = 0;
for (int j = i; j > 0; j--) {
sum += towers[j];
if (sum >= k[j - 1]) {
t[i] = t[j - 1] + 1;
k[i] = sum;
break;
}
}
}
cout << N - t[N] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int fn(long long q) {
if (q <= 9) return q;
int r = (q % 10);
int w;
int d = q;
int s = 0;
while (d > 0) {
w = d;
d /= 10;
}
if (w > r) {
s -= 1;
}
s += (q / 10);
s += 9;
return s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
long long a[n];
long long b[n];
long long s = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
for (long long i = 0; i < n; i++) cin >> b[i];
sort(b, b + n);
long long t = b[n - 1] + b[n - 2];
if (t < s)
cout << "NO";
else
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define fastIO ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
//#pragma G++ optimize("Ofast,no-stack-protector")
//#pragma G++ optimize("-O3,-O2,-O1")
//#pragma G++ target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
//#pragma G++ optimize("unroll-loops")
#define endl "\n"
#define amd and
#define pb push_back
#define f first
#define s second
#define ret return
#define cont continue
#define lcm(x,y) (x*y/__gcd(x,y))
#define all(x) x.begin(),x.end()
#define y1 Popajopa
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef unsigned long long ull;
typedef pair<ll,ll> pll;
typedef long double ld;
typedef char ch;
typedef string str;
typedef bool bl;
typedef void vd;
const ll mod=1e9+7;
/// ///////////////////////////////////////////////////////
ll t,l,o,xj,yj,n,m;
ll oo=1e18,q1,q2;
char c[1001][1001];
ll b[300005],dp[1001][1001],a;
//string s;
pair<ll,ll>q[100001];
int main()
{
ll t;
cin >> t;
while(t--)
{
ll n,k;
cin >> n >> k;
if(n%2==0)
{
if(k%n==0)cout << n << endl;
else cout << k%n << endl;
}
else
{
k--;
if(((k%n + k/((n-1)/2))+1)%n==0)cout << n << endl;
else cout << ((k%n + k/((n-1)/2))+1)%n << endl;
}
}
return 0;
}
/*
4 4
4 2
2 4
1 1 1 1
1 1 1 0
1 1 1 0
1 0 0 0
*/
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct B {
double a, b;
};
int cmp(B x, B y) { return (x.b / x.a) < (y.b / y.a); }
int main() {
B arr[100010];
int i, n;
double sa = 0, sb, t, tnxt, p;
scanf("%d%lf", &n, &p);
for (i = 0; i < n; i++) {
scanf("%lf%lf", &arr[i].a, &arr[i].b);
sa += arr[i].a;
}
if (sa - p < 0.0001) {
printf("-1");
exit(0);
}
sort(arr, arr + n, cmp);
sa = 0;
sb = 0;
for (i = 0; i < n; i++) {
sa += arr[i].a;
sb += arr[i].b;
if (sa - p < 0.0001) continue;
t = sb / (sa - p);
if (i == n - 1) {
printf("%f", t);
exit(0);
}
tnxt = arr[i + 1].b / arr[i + 1].a;
if (tnxt - t > (-0.0001)) {
printf("%f", t);
exit(0);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 5;
const int offset = 3e5;
const int MOD = 1e9 + 7;
int a, b, k, t;
int dp[2][2][N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> a >> b >> k >> t;
for (int player = 0; player <= 1; player++) {
for (int diff = -offset; diff <= offset; diff++) {
dp[player][t + 1 & 1][diff + offset] = (diff > 0);
dp[player][t + 1 & 1][diff + offset] +=
dp[player][t + 1 & 1][diff + offset - 1];
dp[player][t + 1 & 1][diff + offset] %= MOD;
}
}
for (int turn = t; turn >= 1; turn--) {
for (int diff = -offset; diff <= offset; diff++) {
int player = 1;
int &ans = dp[player][turn & 1][diff + offset];
ans = dp[player ^ 1][turn + 1 & 1][diff + k + offset] -
dp[player ^ 1][turn + 1 & 1][diff - k - 1 + offset];
ans += MOD;
ans %= MOD;
ans += dp[player][turn & 1][diff - 1 + offset];
ans %= MOD;
}
for (int diff = -offset; diff <= offset; diff++) {
int player = 0;
int &ans = dp[player][turn & 1][diff + offset];
ans = dp[player ^ 1][turn & 1][diff + k + offset] -
dp[player ^ 1][turn & 1][diff - k - 1 + offset];
ans += MOD;
ans %= MOD;
ans += dp[player][turn & 1][diff - 1 + offset];
ans %= MOD;
}
}
int ans = dp[0][1][a - b + offset] - dp[0][1][a - b - 1 + offset];
ans += MOD;
ans %= MOD;
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char s[123456], t[123456];
int f[123456];
int dp[123456], sum[123456];
void init() {
scanf("%s", s);
scanf("%s", t);
}
void getfail() {
int m = strlen(t);
f[0] = 0;
f[1] = 0;
for (int i = 1; i < m; i++) {
int j = f[i];
while (j && t[i] != t[j]) j = f[j];
f[i + 1] = (t[i] == t[j] ? j + 1 : 0);
}
}
void solve() {
getfail();
int j = 0, maxj = 0, n = strlen(s), m = strlen(t);
dp[0] = 1;
sum[0] = 1;
for (int i = 0; i < n; i++) {
while (j && s[i] != t[j]) j = f[j];
if (s[i] == t[j]) j++;
if (j == m) {
maxj = i - m + 2;
j = f[j];
}
dp[i + 1] += dp[i] + (maxj ? sum[maxj - 1] : 0);
if (dp[i + 1] >= 1000000007) dp[i + 1] -= 1000000007;
sum[i + 1] = sum[i] + dp[i + 1];
if (sum[i + 1] >= 1000000007) sum[i + 1] -= 1000000007;
}
printf("%d\n", (((dp[n] - 1) % 1000000007 + 1000000007) % 1000000007));
}
int main() {
init();
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n, m;
int cnt = 0, sum = 0, res = 0;
cin >> n >> m;
if (n >= m * 2) {
cout << m;
return 0;
}
if (m >= n * 2) {
cout << n;
return 0;
} else {
cout << (n + m) / 3;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MOD2 = 15000007;
const long long int MAX = 9187201950435737471;
const int N = 100005;
const int M = 100005;
const int INF = 2;
const double EPS = 1e-9;
const long double PI = acos(-1);
long long int po(long long int x, long long int y) {
long long int ret = 1;
while (y > 0) {
if (y & 1) {
ret = (ret * x);
}
y = y >> 1ll;
x = (x * x);
}
return ret;
}
void solve(int T) {
int n, m;
cin >> n >> m;
vector<int> a(m), b(m);
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
}
int x = a[0], y = b[0];
vector<pair<int, int> > v, d;
for (int i = 0; i < m; i++) {
if (a[i] != x && b[i] != x) {
v.push_back({a[i], b[i]});
}
if (a[i] != y && b[i] != y) {
d.push_back({a[i], b[i]});
}
}
map<int, int> mp;
bool ok = 0;
if (v.size() == 0 || d.size() == 0) {
cout << "YES\n";
return;
}
for (int i = 0; i < v.size(); i++) {
mp[v[i].first]++;
mp[v[i].second]++;
if (mp[v[i].first] == v.size() || mp[v[i].second] == v.size()) ok = 1;
}
if (ok) {
cout << "YES\n";
return;
}
ok = 0;
mp.clear();
for (int i = 0; i < d.size(); i++) {
mp[d[i].first]++;
mp[d[i].second]++;
if (mp[d[i].first] == d.size() || mp[d[i].second] == d.size()) ok = 1;
}
if (ok) {
cout << "YES\n";
return;
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
for (int i = 1; i <= T; i++) {
solve(i);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char symmetric[11] = {'A', 'H', 'I', 'M', 'O', 'T', 'U', 'V', 'W', 'X', 'Y'};
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool IsPalindrome(string str) {
if (str.empty()) return false;
long long int i = 0;
long long int j = str.length() - 1;
while (i < j) {
if (str[i] != str[j]) {
return false;
}
i++;
j--;
}
return true;
}
long long int binpow(long long int a, long long int b) {
if (b == 0) return 1;
long long int res = binpow(a, b / 2);
if (b % 2) return (res * res * a);
return (res * res);
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n;
cin >> n;
char a[n][n];
long long int f = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i + j) % 2 == 0)
cout << "W";
else
cout << "B";
}
cout << endl;
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
vector<int> adj[N];
vector<int> tmp;
int k = 0;
bool gl;
int dfs(int v, int p) {
int flg = 0;
int cnt = 0;
for (int i : adj[v]) {
if (i != p) {
cnt++;
flg += dfs(i, v);
}
}
if (v) {
if (flg)
k++;
else
return 1;
} else if (flg)
gl = 1;
return 0;
}
void solve() {
int n;
cin >> n;
for (long long int i = 0; i < n; ++i) adj[i].clear();
for (long long int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
gl = 0;
k = 0;
dfs(0, 0);
cout << n - 2 * k - gl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1, tmp = 0;
cin >> t;
while (t--) {
solve();
if (t) cout << "\n";
}
cerr << "Time : " << (double)clock() / (double)CLOCKS_PER_SEC << "s\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct fenwick_tree_1D {
long long n, log_n;
vector<long long> tree;
fenwick_tree_1D(long long _n)
: n(_n), log_n((long long)(log2(_n) + 1.0L)), tree(_n + 5) {}
void update(long long x, long long v) {
while (x <= n) {
tree[x] += v;
x += x & (-x);
}
}
long long prefix_sum(long long x) {
long long r = 0;
while (x) {
r += tree[x];
x -= x & (-x);
}
return r;
}
long long range_sum(long long l, long long r) {
return prefix_sum(r) - prefix_sum(l - 1);
}
};
const long long bs = 300;
fenwick_tree_1D bit(100005);
long long a[100005], nxt[100005], last[100005] = {0}, dl[2 * bs + 5],
id[100005], dc = 0, result[100005] = {0};
set<long long> s[100005];
long long qc;
struct query {
long long t, l, r, qno;
} q[bs + 5];
long long q2c;
struct query2 {
long long l, r, qno;
} q2[bs + 5];
vector<long long> ans;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
s[a[i]].insert(i);
}
for (long long h = 0; h < m; h += bs) {
qc = min(bs, m - h);
for (long long j = 0; j < qc; j++) {
cin >> q[j].t >> q[j].l >> q[j].r;
q[j].qno = h + j;
if (q[j].t == 1) {
if (!id[a[q[j].l]]) dl[dc] = a[q[j].l], id[a[q[j].l]] = 1, dc++;
if (!id[q[j].r]) dl[dc] = q[j].r, id[q[j].r] = 1, dc++;
} else
q2[q2c].l = q[j].l, q2[q2c].r = q[j].r, q2[q2c].qno = q[j].qno,
ans.push_back(q[j].qno), q2c++;
}
for (long long i = n; i >= 1; i--) {
if (id[a[i]]) {
nxt[i] = 0;
continue;
}
nxt[i] = last[a[i]];
if (nxt[i]) bit.update(nxt[i], nxt[i] - i);
last[a[i]] = i;
}
sort(q2, q2 + q2c,
[](const query2 &l, const query2 &r) { return l.l < r.l; });
long long pos = 1;
for (long long i = 0; i < q2c; i++) {
while (pos < q2[i].l) {
if (id[a[pos]] || !nxt[pos]) {
pos++;
continue;
}
bit.update(nxt[pos], pos - nxt[pos]);
pos++;
}
result[q2[i].qno] = bit.prefix_sum(q2[i].r);
}
for (long long i = 0; i < qc; i++) {
if (q[i].t == 1) {
s[a[q[i].l]].erase(q[i].l);
a[q[i].l] = q[i].r;
s[a[q[i].l]].insert(q[i].l);
} else {
for (long long j = 0; j < dc; j++) {
auto it1 = s[dl[j]].lower_bound(q[i].l);
auto it2 = s[dl[j]].upper_bound(q[i].r);
if (it1 != s[dl[j]].end() && it2 != s[dl[j]].begin()) {
it2--;
if (*it2 > *it1) result[q[i].qno] += *it2 - *it1;
}
}
}
}
for (long long i = 0; i < dc; i++) id[dl[i]] = 0;
dc = 0;
q2c = 0;
for (long long i = 1; i <= n; i++) bit.tree[i] = 0, last[i] = 0;
}
for (auto &k : ans) cout << result[k] << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, e;
int f[330];
vector<int> id[100010];
int main() {
scanf("%d%d%d%d", &n, &m, &s, &e);
f[0] = 0;
for (int i = 1; i <= 300; i++) f[i] = n + 1;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
id[x].push_back(i);
}
int ret = 0;
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
for (int j = 300; j >= 0; j--) {
if (f[j] < n) {
vector<int>::iterator it =
upper_bound(id[x].begin(), id[x].end(), f[j]);
if (it != id[x].end()) {
f[j + 1] = min(f[j + 1], *it);
if ((j + 1) * e + i + f[j + 1] <= s) ret = max(ret, j + 1);
}
}
}
}
printf("%d", ret);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
char c = getchar();
int num = 0;
while ('0' > c || c > '9') c = getchar();
while ('0' <= c && c <= '9') num = num * 10 + c - '0', c = getchar();
return (num);
}
int wr[20], wt;
inline void Write(int x) {
if (!x) {
puts("0");
return;
}
for (; x; x /= 10) wr[++wt] = x % 10;
for (; wt; wt--) putchar('0' + wr[wt]);
puts("");
}
int ak[50010 * 4], n, m, q;
vector<pair<int, int> > ad[50010 * 4];
inline void Ins(int x, int l, int r, int a, int b, pair<int, int> c) {
int md = (l + r) / 2;
if (l == a && r == b) {
ad[x].push_back(c);
return;
}
if (b <= md) Ins(x * 2, l, md, a, b, c);
if (md < a) Ins(x * 2 + 1, md + 1, r, a, b, c);
if (a <= md && md < b) {
Ins(x * 2, l, md, a, md, c);
Ins(x * 2 + 1, md + 1, r, md + 1, b, c);
}
}
inline void Cov(int x, int l, int r, int a) {
int md = (l + r) / 2;
if (l == r) {
ak[x] = 1;
return;
}
if (a <= md)
Cov(x * 2, l, md, a);
else
Cov(x * 2 + 1, md + 1, r, a);
}
long long F[20][2010];
inline void Dfs(int x, int l, int r, int d) {
for (int i = 0; i <= m; i++) F[d][i] = F[d - 1][i];
for (int i = 0; i < ad[x].size(); i++) {
pair<int, int> ii = ad[x][i];
for (int j = m; j >= ii.second; j--)
F[d][j] = max(F[d][j], F[d][j - ii.second] + ii.first);
}
if (l == r) {
if (ak[x]) {
int as = 0;
for (int w = 1, i = 1; i <= m; i++, w = w * 1ll * 10000019 % 1000000007)
as = (as + w * 1ll * F[d][i] % 1000000007) % 1000000007;
Write(as);
}
return;
}
int md = (l + r) / 2;
Dfs(x * 2, l, md, d + 1);
Dfs(x * 2 + 1, md + 1, r, d + 1);
}
pair<int, int> a[50010];
int st[50010];
int main() {
n = Read(), m = Read();
for (int i = 1; i <= n; i++)
a[i].first = Read(), a[i].second = Read(), st[i] = 1;
q = Read();
for (int i = 1; i <= q; i++) {
int op = Read();
if (op == 1) st[++n] = i, a[n].first = Read(), a[n].second = Read();
if (op == 2) {
int x = Read();
Ins(1, 1, q, st[x], i, a[x]), st[x] = 0;
}
if (op == 3) Cov(1, 1, q, i);
}
for (int i = 1; i <= n; i++)
if (st[i]) Ins(1, 1, q, st[i], q, a[i]);
Dfs(1, 1, q, 1);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 401;
int g[LIM][LIM];
int main() {
int n, m;
string rows, cols;
cin >> n >> m >> rows >> cols;
int t = n * m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int v = m * i + j;
int i1 = (cols[j] == '^') ? i - 1 : i + 1;
if (i1 >= 0 && i1 < n) {
int u = m * i1 + j;
g[v][u] = 1;
}
int j1 = (rows[i] == '<') ? j - 1 : j + 1;
if (j1 >= 0 && j1 < m) {
int u = m * i + j1;
g[v][u] = 1;
}
}
}
for (int k = 0; k < t; ++k) {
for (int i = 0; i < t; ++i) {
for (int j = 0; j < t; ++j) {
g[i][j] |= g[i][k] & g[k][j];
}
}
}
bool good = true;
for (int i = 0; i < t && good; ++i) {
for (int j = 0; j < t && good; ++j) {
good = (g[i][j] == 1);
}
}
if (good) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
long long N;
vector<vector<pair<int, int> > > G(MX);
vector<int> vis(MX), lev(MX), dist(MX), par(MX);
vector<int> leaf;
int BFS(int second) {
int ans = 0;
deque<int> DQ;
DQ.push_back(second);
dist[second] = 0;
vis[second] = true;
while (!DQ.empty()) {
int node = DQ.front();
DQ.pop_front();
for (int i = 0; i < G[node].size(); i++) {
int child = G[node][i].first;
int wc = G[node][i].second;
if (vis[child]) continue;
vis[child] = true;
par[child] = node;
dist[child] = dist[node] + wc;
DQ.push_back(child);
ans = max(ans, dist[child]);
}
}
return ans;
}
long long dp[MX];
long long DFS(int node, int par) {
long long ret = 0;
for (int i = 0; i < G[node].size(); i++) {
int child = G[node][i].first;
int w = G[node][i].second;
bool boys = false;
if (child != par) {
dp[child] = dp[node] + w;
ret = max(ret, w + DFS(child, node));
boys = true;
}
if (!boys) leaf.push_back(node);
}
return ret;
}
void go_solver() {
ios::sync_with_stdio(false);
cin >> N;
long long paths = 0;
for (int i = 1; i < N; i++) {
int fr, to, w;
cin >> fr >> to >> w;
G[fr].push_back(make_pair(to, w));
G[to].push_back(make_pair(fr, w));
paths += w;
}
paths *= 2LL;
long long LP = 0;
long long dfs = DFS(1, -1);
for (int i = 0; i < leaf.size(); i++) LP = max(LP, dp[leaf[i]]);
cout << paths - LP << "\n";
}
int main() {
go_solver();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 100;
const int inf = 0x3f3f3f3f;
char s[100];
int have[100];
int n;
int d[N];
struct edge {
int v, w;
};
vector<edge> G[N];
int op1() {
if (have[1] || have[2] || have[3]) return 1;
return 0;
}
void dij() {
for (int i = 1; i <= n; i++) d[i] = i == 1 ? 0 : inf;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
Q;
Q.push(pair<int, int>(0, 1));
while (!Q.empty()) {
pair<int, int> t = Q.top();
Q.pop();
int dis = t.first;
int u = t.second;
if (dis != d[u]) continue;
for (int i = 0; i < G[u].size(); i++) {
edge e = G[u][i];
int v = e.v;
int w = e.w;
if (d[v] > d[u] + w) {
d[v] = d[u] + w;
Q.push(pair<int, int>(d[v], v));
}
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
G[i].push_back((edge){i + 1, 1});
G[i + 1].push_back((edge){i, 1});
}
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
G[i].push_back((edge){t, 1});
}
dij();
for (int i = 1; i <= n; i++) {
printf("%d%c", d[i], i == n ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long a, long b) { return ((a * b) / gcd(a, b)); }
long long a[100000];
int main() {
long long i, j, k, l, m, n, maxx = 0, g = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n; i++) {
while (a[i] % 2 == 0) {
a[i] /= 2;
}
while (a[i] % 3 == 0) {
a[i] /= 3;
}
}
sort(a, a + n);
if (a[0] == a[n - 1])
cout << "Yes" << endl;
else
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long s(long long x) {
long long i = 0;
while (x > 0) {
i += x % 10;
x /= 10;
}
return i;
}
int main() {
long long x, y, l, r, xa = 1, yb = 1, mx, i;
;
cin >> x >> y >> l >> r;
vector<long long> vec;
if (l <= 2) vec.push_back(2);
while ((double)yb * y <= 1e18 && 1 + yb * y <= r) {
yb *= y;
if (1 + yb >= l) vec.push_back(1 + yb);
}
while ((double)xa * x <= 1e18 && xa * x + 1 <= r) {
xa *= x;
yb = 1;
if (xa + 1 >= l) vec.push_back(xa + 1);
while ((double)yb * y <= 1e18 && xa + yb * y <= r) {
yb *= y;
if (xa + yb >= l) vec.push_back(xa + yb);
}
}
sort(vec.begin(), vec.end());
if (vec.size())
mx = *vec.begin() - l;
else
mx = r - l + 1;
for (i = 0; i < vec.size(); i++) mx = max(mx, vec[i] - vec[i - 1] - 1);
if (vec.size()) mx = max(mx, r - *(vec.end() - 1));
cout << mx << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, l, r, t;
int cnt[200][200], cnt2[200][200];
bool used[200][200], used2[200][200];
char a[200][200];
int x[200 * 200], y[200 * 200];
int u, v, u2, v2, tu, tv;
bool first;
bool valid(int u, int v) {
if (u > 0 && v > 0 && u <= n && v <= n) return true;
return false;
}
void bfs(int u, int v) {
l = r = 1;
int u2, v2;
x[l] = u;
used[u][v] = true;
y[l] = v;
cnt[u][v] = 1;
while (l <= r) {
u = x[l];
v = y[l];
if (!used[u - 2][v + 2] && valid(u - 2, v + 2)) {
tu = u - 2;
tv = v + 2;
r++;
x[r] = tu;
y[r] = tv;
used[tu][tv] = true;
cnt[tu][tv] = cnt[u][v] + 1;
}
if (!used[u + 2][v + 2] && valid(u + 2, v + 2)) {
tu = u + 2;
tv = v + 2;
r++;
x[r] = tu;
y[r] = tv;
cnt[tu][tv] = cnt[u][v] + 1;
used[tu][tv] = true;
}
if (!used[u - 2][v - 2] && valid(u - 2, v - 2)) {
tu = u - 2;
tv = v - 2;
r++;
x[r] = tu;
y[r] = tv;
cnt[tu][tv] = cnt[u][v] + 1;
used[tu][tv] = true;
}
if (!used[u + 2][v - 2] && valid(u + 2, v - 2)) {
tu = u + 2;
tv = v - 2;
r++;
x[r] = tu;
y[r] = tv;
cnt[tu][tv] = cnt[u][v] + 1;
used[tu][tv] = true;
}
l++;
}
}
void bfs2(int u, int v) {
l = r = 1;
x[l] = u;
y[l] = v;
used2[u][v] = true;
cnt2[u][v] = 1;
while (l <= r) {
u = x[l];
v = y[l];
if (!used2[u - 2][v + 2] && valid(u - 2, v + 2)) {
tu = u - 2;
tv = v + 2;
r++;
x[r] = tu;
y[r] = tv;
cnt2[tu][tv] = cnt2[u][v] + 1;
used2[tu][tv] = true;
}
if (!used2[u + 2][v + 2] && valid(u + 2, v + 2)) {
tu = u + 2;
tv = v + 2;
r++;
x[r] = tu;
y[r] = tv;
cnt2[tu][tv] = cnt2[u][v] + 1;
used2[tu][tv] = true;
}
if (!used2[u - 2][v - 2] && valid(u - 2, v - 2)) {
tu = u - 2;
tv = v - 2;
r++;
x[r] = tu;
y[r] = tv;
cnt2[tu][tv] = cnt2[u][v] + 1;
used2[tu][tv] = true;
}
if (!used2[u + 2][v - 2] && valid(u + 2, v - 2)) {
tu = u + 2;
tv = v - 2;
r++;
x[r] = tu;
y[r] = tv;
cnt2[tu][tv] = cnt2[u][v] + 1;
used2[tu][tv] = true;
}
l++;
}
}
void cl() {
for (int i = 1; i <= n; i++)
a[0][i] = '#', a[n + 1][i] = '#', a[i][0] = '#', a[i][n + 1] = '#';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
cnt[i][j] = cnt2[i][j] = 0;
used[i][j] = used2[i][j] = false;
}
}
int main() {
scanf("%d\n", &t);
while (t--) {
n = 8;
first = false;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
scanf("%c", &a[i][j]);
if (a[i][j] == 'K' && !first) {
u = i;
v = j;
first = true;
} else if (first && a[i][j] == 'K')
u2 = i, v2 = j;
}
scanf("\n");
}
scanf("\n");
cl();
bfs(u, v);
bfs2(u2, v2);
string ans = "NO";
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (a[i][j] != '#' && cnt[i][j] && cnt2[i][j] && cnt[i][j] &&
cnt[i][j] % 2 == cnt2[i][j] % 2)
ans = "YES";
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x, y, l, r, fact[200001], mod = 1e9 + 7;
map<int, int> m;
int powlog(int a, int b) {
if (b == 0) return 1;
int ret = powlog(a, b / 2);
if (b % 2) return 1LL * ret * ret % mod * a % mod;
return 1LL * ret * ret % mod;
}
int C(int n, int r) {
return 1LL * fact[n] * powlog(1LL * fact[r] * fact[n - r] % mod, mod - 2) %
mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
fact[0] = 1;
for (int i = 1; i <= 200000; i++) fact[i] = 1LL * i * fact[i - 1] % mod;
cin >> n >> k;
for (int i = 0; i < n && cin >> x >> y; i++) m[x]++, m[y + 1]--;
long long ans = 0;
int prev = 0, lines = 0;
for (auto &i : m) {
if (lines >= k)
ans = (ans + 1LL * (i.first - prev) * C(lines, k) % mod) % mod;
lines += i.second;
prev = i.first;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
bool bAndW = true;
cin >> n >> m;
n *= m;
while (n--) {
char c;
cin >> c;
if (c != 'W' && c != 'G' && c != 'B') {
bAndW = false;
break;
}
}
cout << (bAndW ? "#Black&White" : "#Color");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, t, ans;
struct node {
int x, y, z;
} a[maxn];
inline bool cmp(const node& A, const node& B) {
return A.y < B.y || (A.y == B.y && A.x < B.x);
}
inline bool check(int N) {
int T = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (a[i].x >= N) {
if (a[i].y + T > t) break;
cnt++;
T += a[i].y;
}
}
return cnt >= N;
}
int main() {
scanf("%d%d", &n, &t);
for (int i = 1; i <= n; ++i) scanf("%d%d", &a[i].x, &a[i].y), a[i].z = i;
sort(a + 1, a + 1 + n, cmp);
int L = 0, R = n + 1;
while (L + 1 < R) {
int mid = (L + R) >> 1;
if (check(mid))
L = mid;
else
R = mid;
}
if (check(R))
ans = R;
else
ans = L;
int sum = 0;
printf("%d\n%d\n", ans, ans);
for (int i = 1; i <= n && sum < ans; ++i)
if (a[i].x >= ans) printf("%d ", a[i].z), sum++;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool arr[1000000];
set<int> primes;
void seive() {
for (int i = 2; i < 1000000; i++) {
if (arr[i]) continue;
primes.insert(i);
for (int j = i; j < 1000000; j += i) arr[j] = 1;
}
}
int main() {
seive();
int n;
cin >> n;
int m;
for (m = 1; m <= 1000; m++)
if (primes.count(m * n + 1) == 0) break;
cout << m;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int n;
string s;
int dp[5][1000010];
int main() {
int i, n, ans;
cin >> s;
n = s.length();
if ((s[0] == '0') || (s[0] == '?')) dp[0][0]++;
if ((s[0] == '1') || (s[0] == '?')) dp[1][0]++;
if ((s[0] == '*') || (s[0] == '?')) dp[4][0]++;
for (i = 1; i < n; i++) {
if ((s[i] == '0') || (s[i] == '?')) {
dp[0][i] = (dp[0][i] + dp[0][i - 1]) % MOD;
dp[0][i] = (dp[0][i] + dp[2][i - 1]) % MOD;
}
if ((s[i] == '1') || (s[i] == '?')) {
dp[1][i] = (dp[1][i] + dp[0][i - 1]) % MOD;
dp[1][i] = (dp[1][i] + dp[2][i - 1]) % MOD;
dp[2][i] = (dp[2][i] + dp[4][i - 1]) % MOD;
}
if ((s[i] == '2') || (s[i] == '?'))
dp[3][i] = (dp[3][i] + dp[4][i - 1]) % MOD;
if ((s[i] == '*') || (s[i] == '?')) {
dp[4][i] = (dp[4][i] + dp[4][i - 1]) % MOD;
dp[4][i] = (dp[4][i] + dp[1][i - 1]) % MOD;
dp[4][i] = (dp[4][i] + dp[3][i - 1]) % MOD;
}
}
ans = (dp[0][n - 1] + dp[2][n - 1]) % MOD;
ans = (ans + dp[4][n - 1]) % MOD;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int sum = 0, sum1 = 0;
int n, x, y, d;
cin >> n >> x >> y >> d;
if ((y - x) % d == 0 || (x - y) % d == 0) {
cout << abs(y - x) / d << endl;
continue;
} else {
if ((y - 1) % d && (n - y) % d) {
cout << -1 << endl;
continue;
} else {
if ((x - 1) % d) {
sum++;
}
sum += (x - 1) / d;
sum += (y - 1) / d;
if ((n - x) % d) {
sum1++;
}
sum1 += (n - x) / d;
sum1 += (n - y) / d;
if ((y - 1) % d == 0 && (n - y) % d == 0)
cout << min(sum, sum1) << endl;
else if ((y - 1) % d == 0)
cout << sum << endl;
else
cout << sum1 << endl;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, l, r, sall, sk;
int ans[1001];
int main() {
while (~scanf("%d%d%d%d%d%d", &n, &k, &l, &r, &sall, &sk)) {
for (int i = 1; i <= n; i++) ans[i] = l;
sall -= l * n;
while (sall > 0) {
for (int i = 1; i <= n; i++) {
ans[i]++;
sall--;
if (sall <= 0) break;
}
if (sall <= 0) break;
}
int sum = 0;
for (int i = 1; i <= k; i++) {
sum += ans[i];
}
sk -= sum;
int p = sk;
while (sk > 0) {
for (int i = 1; i <= k; i++) {
if (ans[i] + 1 <= r) {
ans[i]++;
sk--;
}
if (sk <= 0) break;
}
if (sk <= 0) break;
}
int ss = 0;
while (ss < p) {
for (int i = k + 1; i <= n; i++) {
ans[i]--;
ss++;
if (ss >= p) break;
}
if (ss >= p) break;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int t, n, m;
long long int ans;
cin >> t;
while (t--) {
ans = 0;
cin >> n >> m;
vector<pair<long long int, long long int>> v(m);
for (int i = 0; i < m; ++i) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end(), greater<pair<int, int>>());
vector<long long int> vclone(m);
for (int i = 0; i < m; ++i) vclone[i] = v[i].first;
vector<long long int> prefix_sum(m);
prefix_sum[0] = v[0].first;
for (int i = 1; i < m; ++i) prefix_sum[i] = prefix_sum[i - 1] + v[i].first;
for (int i = 0; i < m; ++i) {
int idx = upper_bound(vclone.begin(), vclone.end(), v[i].second,
greater<int>()) -
vclone.begin();
if (idx >= n)
ans = max(ans, prefix_sum[n - 1]);
else {
long long int ts = 0;
if (idx - 1 >= 0) ts = prefix_sum[idx - 1];
if (i < idx)
ans = max(ans, ts + (n - idx) * v[i].second);
else
ans = max(ans, ts + v[i].first + (n - idx - 1) * v[i].second);
}
}
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
map<string, int> m;
int main() {
cin >> n;
m["void"] = 0;
for (int i = 0; i < (n); i++) {
string o;
cin >> o;
if (o == "typedef") {
string s1, s2;
cin >> s1 >> s2;
int c1 = 0, c2 = 0;
while (s1[0] == '&') {
c1++;
s1.erase(0, 1);
}
while (s1[((int)(s1).size()) - 1] == '*') {
c2++;
s1.erase(((int)(s1).size()) - 1, 1);
}
if (m.count(s1)) {
int x = m[s1] + c2 - c1;
if (x >= 0)
m[s2] = x;
else
m.erase(s2);
} else
m.erase(s2);
} else {
string s1;
cin >> s1;
int c1 = 0, c2 = 0;
while (s1[0] == '&') {
c1++;
s1.erase(0, 1);
}
while (s1[((int)(s1).size()) - 1] == '*') {
c2++;
s1.erase(((int)(s1).size()) - 1, 1);
}
if (m.count(s1)) {
int x = m[s1] + c2 - c1;
if (x >= 0) {
cout << "void";
for (int j = 0; j < (x); j++) cout << "*";
cout << endl;
} else
cout << "errtype" << endl;
} else
cout << "errtype" << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int maximize(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline int minimize(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int N = 151, INF = 0x3f3f3f3f, mod = 1000000007;
template <class T>
inline void add(T& a, T b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
int n, m, dp[N][N][4], prefix[N][N][4], f[N][N][4][4];
long long ans;
int main() {
cin >> n >> m;
if (n < m) swap(n, m);
for (int j = 1; j <= m; ++j) {
for (int k = j; k <= m; ++k) {
add(ans, 1LL * n);
dp[j][k][0] = 1;
}
}
for (int i = 2; i <= n; ++i) {
for (int k = 1; k <= m; ++k) {
for (int j = k; j >= 1; --j) {
for (int p = 0; p < 4; ++p) {
prefix[k][j][p] = prefix[k][j + 1][p];
add(prefix[k][j][p], dp[j][k][p]);
}
}
}
for (int j = 1; j <= m; ++j) {
for (int k = 1; k <= m; ++k) {
for (int p = 0; p < 4; ++p) {
f[j][k][p][0] = f[j][k - 1][p][0];
add(f[j][k][p][0], prefix[k][j][p]);
f[j][k][p][1] = f[j][k - 1][p][1];
add(f[j][k][p][1], prefix[k][1][p] - prefix[k][j + 1][p]);
}
}
for (int k = m; k >= 1; --k) {
for (int p = 0; p < 4; ++p) {
f[j][k][p][2] = f[j][k + 1][p][2];
add(f[j][k][p][2], prefix[k][j][p]);
f[j][k][p][3] = f[j][k + 1][p][3];
add(f[j][k][p][3], prefix[k][1][p] - prefix[k][j + 1][p]);
}
}
}
memset(dp, 0, sizeof(dp));
for (int j = 1; j <= m; ++j) {
for (int k = j; k <= m; ++k) {
add(dp[j][k][0], f[j][k][0][0]);
add(dp[j][k][1], f[j][k][1][1] - f[j][j - 1][1][1]);
add(dp[j][k][1], f[j - 1][k][0][1] - f[j][j - 1][0][1]);
add(dp[j][k][2], f[j][k][2][2] - f[k + 1][k][2][2]);
add(dp[j][k][2], f[j][k + 1][0][2] - f[k + 1][k][0][2]);
add(dp[j][k][3], f[j - 1][k + 1][0][3]);
add(dp[j][k][3], f[j][k + 1][1][3]);
add(dp[j][k][3], f[j - 1][k][2][3]);
add(dp[j][k][3], f[j][k][3][3]);
for (int p = 0; p < 4; ++p)
add(ans, dp[j][k][p] * (long long)(n - i + 1) % mod);
}
}
}
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long modd = 1e9 + 7;
const int maxn = 100000 + 10;
string str;
long long s, k, len, f[maxn];
long long gcd(int a, int b) { return (!b) ? a : gcd(b, a % b); }
long long lcm(int a, int b) { return a / gcd(a, b) * b; }
void exgcd(long long a, long long b, long long &d, long long &x, long long &y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
long long reverse(long long a, long long n) {
long long x, y, d;
exgcd(a, n, d, x, y);
return (d == 1) ? (x + n) % n : -1;
}
long long quick_mod(long long a, long long b, long long c) {
a %= c;
long long ans = 1;
while (b > 0) {
if ((b & 1) != 0) ans = (a * ans) % c;
a = (a * a) % c;
b >>= 1;
}
return ans;
}
void init() {
f[0] = 1;
for (long long i = 1; i <= 100005; i++) f[i] = f[i - 1] * 2 % modd;
}
int main() {
init();
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> str >> k;
len = str.length();
long long d = (quick_mod(f[len], k, modd) - 1) % modd *
reverse(f[len] - 1, modd) % modd;
for (int i = 0; i < str.length(); i++)
if (str[i] == '0' || str[i] == '5') s = (s + f[i]) % modd;
cout << s % modd * d % modd << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d[256] = {0}, n;
string s;
cin >> s >> n;
for (int i = 0; i < int(s.size()); i++) d[s[i]]++;
int cntDif = 0;
for (char c = 'a'; c <= 'z'; c++)
if (d[c]) cntDif++;
if (cntDif > n)
puts("-1");
else
for (int ans = 1; ans <= 10000; ans++) {
int need = 0;
for (char c = 'a'; c <= 'z'; c++) need += (d[c] + ans - 1) / ans;
if (need <= n) {
cout << ans << endl;
for (char c = 'a'; c <= 'z'; c++)
for (int i = 0; i < (d[c] + ans - 1) / ans; i++) cout << c;
while (need < n) need++, cout << 'a';
cout << endl;
break;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void files(bool in, char *s) {
if (in)
freopen(s, "r", stdin);
else
freopen(s, "w", stdout);
}
const double PI = 4 * atan(1.0);
const double EPS = 1e-9;
const int infi = (int)1e9;
const long long infl = (long long)1e17;
const int MOD = (int)1e9 + 7;
const int MAX = (int)1e6 + 22;
const int dx[] = {0, 1, -1, 0, 0, 1, 1, -1, -1};
const int dy[] = {0, 0, 0, -1, 1, 1, -1, 1, -1};
const int kdx[] = {1, 1, -1, -1, 2, 2, -2, -2};
const int kdy[] = {2, -2, 2, -2, 1, -1, 1, -1};
long long n;
long long a[MAX];
pair<long long, long long> p[MAX];
long long seg[4 * MAX];
void update(long long st, long long en, long long idx, long long l,
long long r) {
if (l > en || r < st) return;
if (l <= st && en <= r) {
seg[idx]++;
return;
}
long long mid = (st + en) / 2;
update(st, mid, 2 * idx, l, r);
update(mid + 1, en, 2 * idx + 1, l, r);
}
long long query(long long st, long long en, long long idx, long long x) {
if (st != en && seg[idx]) {
seg[2 * idx] += seg[idx];
seg[2 * idx + 1] += seg[idx];
seg[idx] = 0;
}
if (x > en || x < st) return 0;
if (st == en) return (st == x ? seg[idx] : 0);
long long mid = (st + en) / 2;
long long lf = query(st, mid, 2 * idx, x);
long long rt = query(mid + 1, en, 2 * idx + 1, x);
return lf + rt;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i].first;
p[i].second = i;
}
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++) a[p[i].second] = i;
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long bfr_grt = query(1, n, 1, a[i]);
long long bfr_lss = i - bfr_grt - 1;
long long atr_lss = (a[i] - 1 - bfr_lss);
ans += bfr_grt * atr_lss;
update(1, n, 1, 1, a[i]);
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e8;
void solve() {
long long a, b, n;
cin >> a >> b >> n;
a *= 10;
long long temp = ((a + b - 1) / b) * b - a;
if (temp > 9)
cout << "-1\n";
else {
n--;
a += temp;
cout << a;
for (long long i = 0; i < n; i++) cout << "0";
cout << "\n";
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
string s;
cin >> s;
if (n == 1 && k >= 1) {
cout << 0;
return 0;
}
long long i = 0;
while (k != 0 && i < (int)s.length()) {
if (i == 0 && s[i] != '1') s[i] = '1', k--;
if (i != 0 && s[i] != '0') s[i] = '0', k--;
i++;
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int N = 2e5 + 10;
int n[5];
int a[5][N];
map<int,int> mp[5][N];
vector<pair<int,int>> v1, v2;
void solve() {
for (int i = 1; i <= 4; i++) {
cin >> n[i];
}
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n[i]; j++) {
cin >> a[i][j];
}
}
for (int i = 2; i <= 4; i++) {
int m;
cin >> m;
for (int j = 1; j <= m; j++) {
int x, y;
cin >> x >> y;
mp[i][y][x] = 1;
}
}
for (int i = 1; i <= n[1]; i++) {
v1.push_back({a[1][i], i});
}
sort(v1.begin(), v1.end());
for (int i = 2; i <= 4; i++) {
v2.clear();
for (int j = 1; j <= n[i]; j++) {
int it = 0;
while (it < v1.size() && mp[i][j].count(v1[it].second) != 0) {
it++;
}
if (it != v1.size()) {
v2.push_back({v1[it].first + a[i][j], j});
}
}
sort(v2.begin(), v2.end());
swap(v1, v2);
}
if (v1.size() == 0) {
cout << "-1\n";
} else {
cout << v1.begin()->first << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
// int t;
// cin >> t;
//
// while (t--) {
solve();
// }
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
const int limite = 1000000;
const int base = 315;
const int tope = 600;
const long long int infinito = 1000000000000000000LL;
int n;
long long int a[limite];
int metido[limite];
int quien[limite];
long long int valor[limite];
long long int sumapre[limite];
int numpre[limite];
long long int entra[limite];
int cuantos[tope];
int indice[tope];
int bnumpre[tope];
long long int bsumapre[tope];
int busca(int b, int k) {
int ib = b * base;
while (indice[b] < ib + cuantos[b] - 1 and entra[indice[b] + 1] <= k)
indice[b]++;
return indice[b];
}
void obtenentra(int i) {
long long int x = valor[i - 1] * (numpre[i - 1] + 1) -
valor[i] * (numpre[i] + 1) + sumapre[i] - sumapre[i - 1];
long long int y = valor[i] - valor[i - 1];
long long int k = x / y + (x % y > 0);
entra[i] = k;
}
void actualiza(int b) {
int ib = b * base;
long long int &spre = bsumapre[b];
int &npre = bnumpre[b];
int &cb = cuantos[b];
spre = npre = cb = 0;
indice[b] = ib;
for (int i = ib; i < n and i < ib + base; i++) {
if (metido[i]) {
spre += a[i];
npre++;
} else if (cb == 0 or a[i] > valor[ib + cb - 1]) {
sumapre[ib + cb] = spre;
numpre[ib + cb] = npre;
valor[ib + cb] = a[i];
quien[ib + cb] = i;
for (;;) {
if (cb == 0) {
entra[ib + cb] = 0;
cb++;
break;
} else {
obtenentra(ib + cb);
if (entra[ib + cb] <= entra[ib + cb - 1]) {
sumapre[ib + cb - 1] = sumapre[ib + cb];
numpre[ib + cb - 1] = numpre[ib + cb];
valor[ib + cb - 1] = valor[ib + cb];
quien[ib + cb - 1] = quien[ib + cb];
cb--;
} else {
cb++;
break;
}
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int b = 0; b * base < n; b++) actualiza(b);
long long int sol = 0;
long long int solact = 0;
long long int stotal = 0;
for (int paso = 0; paso < n; paso++) {
long long int aumento = -infinito;
int iaumento = -1;
long long int spre = 0;
long long int npre = 0;
for (int b = 0; b * base < n; b++) {
if (cuantos[b] > 0) {
int i = busca(b, npre);
long long int aumentoact =
stotal - (spre + sumapre[i]) + (npre + numpre[i] + 1) * valor[i];
if (aumentoact > aumento) {
aumento = aumentoact;
iaumento = quien[i];
}
}
npre += bnumpre[b];
spre += bsumapre[b];
}
if (aumento <= 0) break;
solact += aumento;
metido[iaumento] = 1;
stotal += a[iaumento];
sol = max(sol, solact);
actualiza(iaumento / base);
}
cout << sol << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[1000050];
int go[1000050], n, q, start;
int nxt(int id) { return (id < n ? id + 1 : 1); }
int dfs(int v, int fl) {
if ((fl && v >= start) || fl > 1)
return 0;
else
return dfs(nxt(go[v]), fl + (nxt(go[v]) <= v)) + 1;
}
void solve(long long b) {
long long s = a[1];
int cur = 1;
for (int i = 1; i <= n; ++i) {
while (nxt(cur) != i && s + 1LL * a[nxt(cur)] <= b) {
s += 1LL * a[nxt(cur)];
cur = nxt(cur);
}
go[i] = cur;
if (cur == i) {
cur++;
s += 1LL * a[cur];
}
s -= 1LL * a[i];
}
int B = -1, best = (int)1e8;
for (int i = 1; i <= n; ++i) {
int d;
if (go[i] > i) {
d = go[i] - i + 1;
} else {
d = n - (i - go[i] - 1);
}
if (d < best) {
B = i;
best = d;
}
}
int l = B;
int r = nxt(go[B]);
int ans = (int)1e8;
if (l == r) ans = 1;
if (l == nxt(r)) ans = 2;
r = nxt(r);
for (int i = l; i != r; i = nxt(i)) {
start = i;
ans = min(ans, dfs(i, 0));
}
printf("%d\n", ans);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < q; ++i) {
long long z;
scanf("%I64d", &z);
solve(z);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long llinf = 0x3f3f3f3f3f3f3f3f;
template <typename INint>
inline void IN(INint &first) {
first = 0;
int f = 1;
char c;
cin.get(c);
while (c < '0' || c > '9') {
if (c == '-') f = -1;
cin.get(c);
}
while (c >= '0' && c <= '9') {
first = first * 10 + c - '0';
cin.get(c);
}
first *= f;
}
template <typename INint>
inline void OUT(INint first) {
if (first > 9) OUT(first / 10);
cout.put(first % 10 + '0');
}
const int maxn = int(2e5 + 5);
struct node {
long long sp, t;
bool operator<(node b) const { return t < b.t; }
} ns[maxn];
int n;
long long TT;
long long sum(0);
long long ans(0);
double fans;
int main() {
int T(1), times(0);
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (++times, T--) {
cin >> n >> TT;
for (int i = 1; i <= int(n); i++) cin >> ns[i].sp, ans += ns[i].sp;
for (int i = 1; i <= int(n); i++)
cin >> ns[i].t, ns[i].t -= TT, sum += ns[i].t * ns[i].sp;
sort(ns + 1, ns + 1 + n);
if (sum < 0) {
reverse(ns + 1, ns + 1 + n);
for (int i = 1; i <= int(n); i++) ns[i].t = -ns[i].t;
sum = -sum;
}
if (sum)
for (int i = n; i >= int(1); --i) {
if (ns[i].sp * ns[i].t < sum) {
sum -= ns[i].sp * ns[i].t;
ans -= ns[i].sp;
} else {
fans = (double)ans - double(sum) / ns[i].t;
sum = 0;
break;
}
}
else
fans = ans;
cout << setprecision(8) << fixed << fans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return (b / gcd(a, b)) * a; }
void print() {}
void pLine() { cout << endl; }
template <typename T, typename... arg>
void print(T x, arg... ar) {
cout << x;
print(ar...);
}
const double PI = acos(-1);
const double eps = numeric_limits<double>::epsilon();
void rem(string &str) {
while (str[0] == '0' and (str).size() - 1) str.erase(0, 1);
}
void sol() {
string x, ans = "";
cin >> x;
int sum = 0;
vector<int> dp[3];
for (int i = (int)0; i < (int)(x).size(); i++) {
int temp = x[i] - '0';
sum = (sum + temp) % 3;
dp[temp % 3].push_back(i);
}
if (!sum) return print(x, '\n');
if (sum == 2) swap(dp[1], dp[2]);
if ((dp[1]).size() >= 1) {
string temp = x;
temp.erase(temp.begin() + dp[1].back());
rem(temp);
if (temp.size() > ans.size()) ans = temp;
}
if ((dp[2]).size() >= 2) {
string temp = x;
temp.erase(temp.begin() + dp[2].back());
temp.erase(temp.begin() + dp[2][(dp[2]).size() - 2]);
rem(temp);
if (temp.size() > ans.size()) ans = temp;
}
if (ans.size() == 0) return print(-1);
print(ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
sol();
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 1e6;
const int mod = 1e9 + 7;
using namespace std;
int n;
char s[N + 5], ns[N + 5];
struct PAM {
int ch[N + 5][26], fail[N + 5], len[N + 5], nc, las, f[N + 5], sf[N + 5],
d[N + 5], pos[N + 5];
char s[N + 5];
void init(char *ch) {
for (int i = 1; i <= n; i++) s[i] = ch[i];
s[0] = '#';
len[1] = -1;
pos[0] = 1;
fail[0] = 1;
f[0] = 1;
nc = 1;
}
void insert(int x) {
int p = las;
while (s[x - len[p] - 1] != s[x]) p = fail[p];
if (!ch[p][s[x] - 'a']) {
len[++nc] = len[p] + 2;
int j = fail[p];
while (s[x - len[j] - 1] != s[x]) j = fail[j];
fail[nc] = ch[j][s[x] - 'a'];
d[nc] = len[nc] - len[fail[nc]];
if (d[nc] == d[fail[nc]])
pos[nc] = pos[fail[nc]];
else
pos[nc] = fail[nc];
ch[p][s[x] - 'a'] = nc;
}
las = ch[p][s[x] - 'a'];
int j = las;
while (j > 1) {
sf[j] = f[x - len[pos[j]] - d[j]];
if (pos[j] != fail[j]) sf[j] += sf[fail[j]], sf[j] %= mod;
if (x % 2 == 0) f[x] += sf[j], f[x] %= mod;
j = pos[j];
}
}
void build() {
for (int i = 1; i <= n; i++) insert(i);
}
} pa;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
int l = 1, r = n;
for (int i = 1; i <= n; i++)
if (i % 2 == 1)
ns[i] = s[l++];
else
ns[i] = s[r--];
pa.init(ns);
pa.build();
cout << pa.f[n] << endl;
return 0;
}
| 10 |
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+10;
int to_L[N],to_R[N],d[N];
char a[N];
int main(){
int t;
cin>>t;
while(t--){
int n;
cin>>n;
memset(to_L,0,sizeof to_L);
memset(to_R,0,sizeof to_R);
memset(d,0,sizeof d);
scanf("%s",a+1);
int step=0;
for(int i=1;i<=n;i++){
if(a[i]!=a[i-1]) step++;
else step=1;
if(a[i]=='L') to_L[i]=step;
}
step=0;
for(int i=n;i>=1;i--){
if(a[i]!=a[i+1]) step++;
else step=1;
if(a[i]=='R') to_R[i-1]=step;
}
for(int i=0;i<=n;i++){
d[i]=to_L[i]+to_R[i]+1;
}
for(int i=0;i<=n;i++){
cout<<d[i]<<' ';
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string ar[1005];
int n, m, dis[4][1005][1005];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int solve() {
memset(dis, -1, sizeof(dis));
priority_queue<pair<int, pair<int, int> > > current;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ar[i][j] == '1') {
dis[1][i][j] = 0;
current.push({0, {i, j}});
}
}
}
while (!current.empty()) {
int x = current.top().second.first;
int y = current.top().second.second;
current.pop();
for (int i = 0; i < 4; i++) {
int tx = x + dx[i];
int ty = y + dy[i];
if (tx >= 0 && ty >= 0 && tx < n && ty < m && ar[tx][ty] != '#') {
int t = 0;
if (ar[tx][ty] == '.') t = 1;
if (dis[1][tx][ty] == -1 || dis[1][tx][ty] > dis[1][x][y] + t) {
dis[1][tx][ty] = dis[1][x][y] + t;
current.push({-dis[1][tx][ty], {tx, ty}});
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ar[i][j] == '2') {
dis[2][i][j] = 0;
current.push({0, {i, j}});
}
}
}
while (!current.empty()) {
int x = current.top().second.first;
int y = current.top().second.second;
current.pop();
for (int i = 0; i < 4; i++) {
int tx = x + dx[i];
int ty = y + dy[i];
if (tx >= 0 && ty >= 0 && tx < n && ty < m && ar[tx][ty] != '#') {
int t = 0;
if (ar[tx][ty] == '.') t = 1;
if (dis[2][tx][ty] == -1 || dis[2][tx][ty] > dis[2][x][y] + t) {
dis[2][tx][ty] = dis[2][x][y] + t;
current.push({-dis[2][tx][ty], {tx, ty}});
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ar[i][j] == '3') {
dis[3][i][j] = 0;
current.push({0, {i, j}});
}
}
}
while (!current.empty()) {
int x = current.top().second.first;
int y = current.top().second.second;
current.pop();
for (int i = 0; i < 4; i++) {
int tx = x + dx[i];
int ty = y + dy[i];
if (tx >= 0 && ty >= 0 && tx < n && ty < m && ar[tx][ty] != '#') {
int t = 0;
if (ar[tx][ty] == '.') t = 1;
if (dis[3][tx][ty] == -1 || dis[3][tx][ty] > dis[3][x][y] + t) {
dis[3][tx][ty] = dis[3][x][y] + t;
current.push({-dis[3][tx][ty], {tx, ty}});
}
}
}
}
int mi = 1e9;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ar[i][j] != '#' && dis[1][i][j] >= 0 && dis[2][i][j] >= 0 &&
dis[3][i][j] >= 0) {
mi = min(mi, dis[1][i][j] + dis[2][i][j] + dis[3][i][j] -
2 * (ar[i][j] == '.'));
}
}
}
if (mi == 1e9) mi = -1;
return mi;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> ar[i];
cout << max(-1, solve()) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 19260817;
const int maxn = 5000 + 5;
int n, b, c[maxn], d[maxn], son[maxn];
int dp[maxn][maxn][2], ans = 0;
bool vis[maxn];
vector<int> e[maxn];
void dfs(int pos) {
int siz = e[pos].size();
son[pos] = 1;
for (int i = 0; i < siz; i++) {
int to = e[pos][i];
if (!vis[to]) {
vis[to] = 1;
dfs(to);
vis[to] = 0;
for (int j = son[pos]; j >= 0; j--)
for (int k = 0; k <= son[to]; k++) {
dp[pos][j + k][0] =
min(dp[pos][j + k][0], dp[pos][j][0] + dp[to][k][0]);
dp[pos][j + k][1] =
min(dp[pos][j + k][1],
dp[pos][j][1] + min(dp[to][k][1], dp[to][k][0]));
}
son[pos] += son[to];
}
}
return;
}
int main() {
scanf("%d%d", &n, &b);
memset(vis, false, sizeof(vis));
memset(dp, 0x3f3f3f, sizeof(dp));
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c[i], &d[i]);
dp[i][0][0] = 0;
dp[i][1][0] = c[i];
dp[i][1][1] = c[i] - d[i];
if (i == 1) {
int pre = 0;
e[pre].push_back(1);
}
if (i >= 2) {
int pre;
scanf("%d", &pre);
e[pre].push_back(i);
}
}
dfs(1);
for (int i = 0; i <= n; i++) {
if (dp[1][i][0] <= b) ans = i;
if (dp[1][i][1] <= b) ans = i;
}
printf("%d", ans);
return 0;
}
| 8 |
#include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define int long long
#define mp make_pair
#define pr pair<long long,long long>
#define vr vector<long long>
#define MOD 1000000007
#define mod 1000000007
#define mod2 998244353
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define ll long long
#define ld long double
#define w(x) int x; cin>>x; while(x--)
#define fill(a,b) memset(a, b, sizeof(a))
#define ios ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int spf[1000002];
//int dp[1000005];
const int N = 200005;
void sieve()
{
for(int i=0;i<5000002;i++)
spf[i]=i;
for(int i=2;i<5000002;i=i+2)
spf[i]=2;
for(int i=3;i*i<5000002;i=i+2)
{
if(spf[i]==i)
{
spf[i]=i;
for(int j=i*i;j<5000002;j=j+i)
{
if(spf[j]==j)
{
spf[j]=i;
}
}
}
}
}
int power(int x, unsigned int y)
{
int res = 1; // Initialize result
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = res*x%mod;
// y must be even now
y = y>>1; // y = y/2
x = x*x % mod; // Change x to x^2
}
return res%mod;
}
int modInv(int a){return power(a,MOD-2);}
int fact[N],inv[N];
void factorial(int n){
fact[0]=1;
for(int i=1;i<=n;i++){
fact[i]=fact[i-1]*i;
if(fact[i]>=MOD)
fact[i]%=MOD;
}
}
void InvFactorial(int n){
inv[0]=1;
for(int i=1;i<=n;i++)
inv[i]=modInv(fact[i]);
}
int ncr(int n,int r){
if(n<r||n<0||r<0)
return 0;
int b=inv[n-r];
int c=inv[r];
int a=fact[n]*b;
if(a>=MOD)
a%=MOD;
a*=c;
if(a>=MOD)
a%=MOD;
return a;
}
bool isPrime(int n)
{
// Corner case
if (n <= 1)
return false;
// Check from 2 to n-1
for (int i = 2; i*i<= n; i++)
if (n % i == 0)
return false;
return true;
}
void solve() {
int n,k;
cin>>n>>k;
int ma=-1e18;
int a[n];
map<int,int> m;
for(int i=0;i<n;i++){
cin>>a[i];
m[a[i]]++;
ma=max(ma,a[i]);
}
int me;
int i=0;
while(1){
if(m[i]==0){
me=i;
break;
}
i++;
}
int ans=n;
//cout<<me<<" "<<ma<<"\n";
if(k==0)ans=n;
else if(me<=ma){
int a=(me+ma+1)/2;
if(m[a]==0)ans++;
m[a]++;
}
else{
ans+=k;
}
cout<<ans<<"\n";
}
int32_t main()
{
ios;
int test;
test=1;
int cas=1;
// factorial(N-1);
// InvFactorial(N-1);
// sieve();
cin>>test;
while(test--)
{
solve();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int dpl[N];
int dpr[N];
int a[N];
int Find1(int lo, int hi, int key) {
int tmp = hi;
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (dpr[mid] > key)
lo = mid + 1;
else
hi = mid;
}
if (dpr[hi] > key) return 0;
return tmp - lo + 1;
}
int Find2(int lo, int hi, int key) {
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2;
if (dpl[mid] - dpl[0] > key)
hi = mid - 1;
else
lo = mid;
}
if (dpl[0] > key) return 0;
return lo;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, a, b, T;
cin >> n >> a >> b >> T;
string s;
cin >> s;
dpl[0] = 1 + (s[0] == 'h' ? 0 : b);
for (int i = 1; i < n; i++) {
if (s[i] == 'h') {
dpl[i] = dpl[i - 1] + a + 1;
} else {
dpl[i] = dpl[i - 1] + a + b + 1;
}
}
dpr[n - 1] = a + 1 + (s[n - 1] == 'h' ? 0 : b) + dpl[0];
for (int i = n - 2; i >= 0; i--) {
dpr[i] = dpr[i + 1] + a + 1 + (s[i] == 'h' ? 0 : b);
}
int sc = 0;
for (int i = 0; i < n; i++) {
if (dpl[i] <= T) {
sc = max(i + 1, sc);
int val = T - i * a - dpl[i];
int sc1 = Find1(i + 1, n - 1, val) + i + 1;
sc = max(sc, sc1);
}
if (dpr[i] <= T) {
sc = max(n - i + 1, sc);
int val = T - (n - i) * a - dpr[i];
int sc2 = Find2(1, i - 1, val) + (n - i + 1);
sc = max(sc, sc2);
}
}
cout << min(sc, n) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dpp[100005], dps[100005];
int main() {
int n, ara[100005], i, ans;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &ara[i]);
}
dpp[0] = 1;
for (i = 1; i < n - 1; i++) {
if (ara[i] > ara[i - 1]) {
dpp[i] = dpp[i - 1] + 1;
} else {
dpp[i] = 1;
}
}
dps[n - 1] = 1;
for (i = n - 1; i > 0; i--) {
if (ara[i - 1] < ara[i]) {
dps[i - 1] = dps[i] + 1;
} else {
dps[i - 1] = 1;
}
}
for (i = 0; i < n; i++) {
if (i == 0) {
ans = dps[1] + 1;
} else if (i == n - 1) {
ans = max(ans, dpp[n - 2] + 1);
} else {
if (ara[i - 1] + 1 < ara[i + 1]) {
ans = max(ans, dpp[i - 1] + dps[i + 1] + 1);
} else {
ans = max(ans, dpp[i - 1] + 1);
ans = max(ans, dps[i + 1] + 1);
}
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
typedef long long LL;
using namespace std;
const int M = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout.setf(ios::fixed);
LL n, i, j, m;
cin >> n;
vector<LL> u(n), v(n), pos(n + 1), npos(n + 1);
for (i = 0; i < n; i++) {
cin >> v[i];
pos[v[i]] = i;
}
for (i = 0; i < n; i++) {
cin >> u[i];
npos[u[i]] = i;
}
vector<pair<LL, LL> > ans;
LL cnt = 0;
for (i = n - 1; i >= 0; i--) {
LL l = pos[u[i]];
LL r = i;
j = l + 1;
for (; j <= r; j++) {
if (npos[v[j]] <= l) {
pos[v[j]] = l;
pos[u[i]] = j;
swap(v[l], v[j]);
ans.push_back(make_pair(l + 1, j + 1));
cnt += (j - l);
l = j;
}
}
}
cout << cnt << '\n';
cout << ans.size() << '\n';
for (i = 0; i < ans.size(); i++)
cout << ans[i].first << ' ' << ans[i].second << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next, v;
} e[2005 * 105];
int head[2005], tot, n;
void add(int x, int y, int v) {
e[++tot] = (edge){y, head[x], v};
head[x] = tot;
}
struct Graph {
int S, sz;
bool vis[2005];
long long dis[2005], b[2005];
void work() {
for (int i = 1; i <= n; i++)
if (i != S) dis[i] = (1ll << 62);
for (int i = 1; i <= n; i++) {
int k = 0;
for (int j = 1; j <= n; j++)
if (!vis[j] && (!k || dis[j] < dis[k])) k = j;
vis[k] = 1;
for (int j = head[k]; j; j = e[j].next)
dis[e[j].to] = min(dis[e[j].to], dis[k] + e[j].v);
}
memcpy(b, dis, sizeof(b));
sort(b + 1, b + n + 1);
sz = unique(b + 1, b + n + 1) - b - 1;
for (int i = 1; i <= n; i++)
dis[i] = lower_bound(b + 1, b + sz + 1, dis[i]) - b;
}
} G[2];
int sz[2005][2005];
long long sum[2005][2005];
long long f[2005][2005][2][2];
bool vis[2005][2005][2][2];
int SZ(int x, int y, int X, int Y) { return sz[x][y] - sz[X][Y]; }
long long SUM(int x, int y, int X, int Y) { return sum[x][y] - sum[X][Y]; }
long long DP(int x, int y, int who, int can) {
if (x > G[0].sz || y > G[1].sz) return 0;
if (vis[x][y][who][can]) return f[x][y][who][can];
vis[x][y][who][can] = 1;
long long ans;
if (who)
ans = DP(x, y + 1, who, can || SZ(x, y, x, y + 1)) + SUM(x, y, x, y + 1);
else
ans = DP(x + 1, y, who, can || SZ(x, y, x + 1, y)) + SUM(x, y, x + 1, y);
if (can) ans = max(ans, -DP(x, y, who ^ 1, 0));
return f[x][y][who][can] = ans;
}
int m, v[2005];
int main() {
scanf("%d%d%d%d", &n, &m, &G[0].S, &G[1].S);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i <= m; i++) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
add(x, y, v);
add(y, x, v);
}
G[0].work();
G[1].work();
for (int i = 1; i <= n; i++) {
sz[G[0].dis[i]][G[1].dis[i]]++;
sum[G[0].dis[i]][G[1].dis[i]] += v[i];
}
for (int i = G[0].sz; i; i--)
for (int j = G[1].sz; j; j--) {
sz[i][j] += sz[i][j + 1] + sz[i + 1][j] - sz[i + 1][j + 1];
sum[i][j] += sum[i][j + 1] + sum[i + 1][j] - sum[i + 1][j + 1];
}
long long ans = DP(1, 1, 0, 0);
if (ans == 0)
puts("Flowers");
else if (ans < 0)
puts("Cry");
else
puts("Break a heart");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b;
cin >> a >> b;
if (a > b && (a - b) != 8) cout << "-1";
if (a == 9 && b == 1)
cout << "9"
<< " "
<< "10";
if ((b - a) > 1 && a != 9 && b != 1) cout << "-1";
if ((b - a) == 1) cout << a << " " << b;
if ((b - a) == 0) cout << a * 10 << " " << a * 10 + 1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dis(long long x1, long long x2, long long y1, long long y2) {
long long a = x1 - x2, b = y1 - y2;
return a * a + b * b;
}
int n;
int p[250005], w[250005];
long long sx, sy, x[250005], y[250005], r[250005], d[250005], data1[500005];
int data2[500005], cnt1, cnt2;
queue<int> q;
struct SGT {
pair<int, int> minn;
set<pair<int, int> > s;
SGT() { minn = make_pair(0x3f3f3f3f, 0x3f3f3f3f); }
} A[500005 << 2];
void Insert(int q, int l, int r, int k, int a, int p) {
if (l == r) {
A[q].minn = min(A[q].minn, make_pair(a, p));
A[q].s.insert(make_pair(a, p));
return;
}
int mid = (l + r) >> 1;
if (k <= mid)
Insert(q << 1, l, mid, k, a, p);
else
Insert(q << 1 | 1, mid + 1, r, k, a, p);
A[q].minn = min(A[q << 1].minn, A[q << 1 | 1].minn);
}
pair<int, int> Query(int q, int l, int r, int L, int R) {
if (l == L && r == R) return A[q].minn;
int mid = (l + r) >> 1;
if (R <= mid) return Query(q << 1, l, mid, L, R);
if (L > mid) return Query(q << 1 | 1, mid + 1, r, L, R);
return min(Query(q << 1, l, mid, L, mid),
Query(q << 1 | 1, mid + 1, r, mid + 1, R));
}
void Delete(int q, int l, int r, int k, int a, int p) {
if (l == r) {
A[q].s.erase(make_pair(a, p));
if (A[q].s.empty())
A[q].minn = make_pair(0x3f3f3f3f, 0x3f3f3f3f);
else
A[q].minn = *(A[q].s.begin());
return;
}
int mid = (l + r) >> 1;
if (k <= mid)
Delete(q << 1, l, mid, k, a, p);
else
Delete(q << 1 | 1, mid + 1, r, k, a, p);
A[q].minn = min(A[q << 1].minn, A[q << 1 | 1].minn);
}
int main() {
scanf("%I64d%I64d%d%I64d%d", &sx, &sy, &p[0], &r[0], &n);
r[0] = r[0] * r[0];
data1[++cnt1] = r[0];
data2[++cnt2] = p[0];
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d%d%d%I64d", &x[i], &y[i], &w[i], &p[i], &r[i]);
d[i] = dis(sx, x[i], sy, y[i]);
r[i] = r[i] * r[i];
data1[++cnt1] = d[i];
data1[++cnt1] = r[i];
data2[++cnt2] = w[i];
data2[++cnt2] = p[i];
}
sort(data1 + 1, data1 + cnt1 + 1);
sort(data2 + 1, data2 + cnt2 + 1);
cnt1 = unique(data1 + 1, data1 + cnt1 + 1) - data1 - 1;
cnt2 = unique(data2 + 1, data2 + cnt2 + 1) - data2 - 1;
for (int i = 1; i <= n; i++) {
d[i] = lower_bound(data1 + 1, data1 + cnt1 + 1, d[i]) - data1;
r[i] = lower_bound(data1 + 1, data1 + cnt1 + 1, r[i]) - data1;
w[i] = lower_bound(data2 + 1, data2 + cnt2 + 1, w[i]) - data2;
p[i] = lower_bound(data2 + 1, data2 + cnt2 + 1, p[i]) - data2;
Insert(1, 1, cnt1, d[i], w[i], i);
}
r[0] = lower_bound(data1 + 1, data1 + cnt1 + 1, r[0]) - data1;
p[0] = lower_bound(data2 + 1, data2 + cnt2 + 1, p[0]) - data2;
q.push(0);
int sum = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
for (;;) {
pair<int, int> st = Query(1, 1, cnt1, 1, r[x]);
if (st.first > p[x]) break;
q.push(st.second);
sum++;
Delete(1, 1, cnt1, d[st.second], st.first, st.second);
}
}
printf("%d\n", sum);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long dp[305][305], at[305][305];
int x[100005], y[100005], c[100005];
int main() {
int n, m, t;
scanf("%d%d%d", &n, &m, &t);
memset(dp, 63, sizeof(dp));
memset(at, 63, sizeof(at));
dp[0][0] = 0;
long long ans = 1ll << 61;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", x + i, y + i, c + i);
x[i]--, y[i]--;
at[x[i]][y[i]] = min(at[x[i]][y[i]], c[i] + 0ll);
}
for (int i = 0; i < n; i++)
for (int j = 1; j <= i; j++) at[j][i] = min(at[j - 1][i], at[j][i]);
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++) {
if (j) dp[i][j] = min(dp[i][j], dp[i - 1][j - 1]);
for (int k = i - 1; ~k; k--)
dp[i][j] = min(dp[i][j], dp[k][j] + at[k][i - 1]);
if (i - j >= t) ans = min(ans, dp[i][j]);
}
if (ans >= 305 * 1000000000ll)
puts("-1");
else
printf("%I64d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ans;
vector<int> primes;
vector<bool> is_prime;
vector<bool> used;
int main() {
int n;
cin >> n;
is_prime.assign(n + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; 2 * i <= n; ++i)
if (is_prime[i]) {
primes.push_back(i);
for (int j = 2 * i; j <= n; j += i) is_prime[j] = false;
}
used.assign(n + 1, false);
for (int i = primes.size() - 1; i >= 0; --i) {
int p = primes[i];
vector<int> a;
int k = p;
while (k <= n) {
if (!used[k]) a.push_back(k);
k += p;
}
if (a.size() < 2) continue;
int p2 = -1;
for (int i = 0; 2 * i + 1 < a.size(); ++i) {
ans.push_back(make_pair(a[2 * i], a[2 * i + 1]));
if (a[2 * i + 1] == 2 * p) p2 = ans.size() - 1;
used[a[2 * i]] = used[a[2 * i + 1]] = true;
}
if (a.size() % 2 == 1 && p2 >= 0) {
ans[p2].second = a[a.size() - 1];
used[2 * p] = false;
used[a[a.size() - 1]] = true;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005;
int d[MAXN][MAXN];
bool p[MAXN][MAXN];
int len, n, l, r;
string s;
int main() {
getline(cin, s);
len = (int)s.length();
for (int i = 1; i <= len; i++)
for (int j = 0; j <= len - i; j++) {
if (i == 1) {
p[j][i] = 1;
continue;
}
if (i == 2) {
p[j][i] = (s[j] == s[j + 1]);
continue;
}
p[j][i] = (p[j + 1][i - 2] && s[j] == s[j + i - 1]);
}
for (int i = 1; i <= len; i++)
for (int j = 0; j <= len - i; j++) {
if (i == 1) {
d[j][i] = 1;
continue;
}
d[j][i] = d[j + 1][i - 1] + d[j][i - 1] - d[j + 1][i - 2];
if (p[j][i]) d[j][i]++;
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &l, &r);
printf("%d\n", d[l - 1][r - l + 1]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long int> sq, nsq;
int n;
cin >> n;
long long int ans = 0;
for (int j = 0; j < n; j++) {
long long int x;
cin >> x;
long long int t = sqrt(x);
if (t * t == x) {
if (x != 0)
sq.push_back(1);
else
sq.push_back(2);
} else {
long long int left = x - t * t;
long long int right = (t + 1) * (t + 1) - x;
nsq.push_back((left > right) ? right : left);
}
}
sort(sq.begin(), sq.end());
sort(nsq.begin(), nsq.end());
long long int req = n / 2;
if (nsq.size() > req) {
int t = nsq.size(), j = 0;
while (t > req) ans += nsq[j++], t--;
} else {
int t = sq.size(), j = 0;
while (t > req) ans += sq[j++], t--;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using LL = long long;
int w, h, n;
void modify(std::set<std::pair<int, int>> &setx, std::multiset<int> &dx,
int p) {
std::set<std::pair<int, int>>::iterator it = --setx.upper_bound({p, -1});
int a = it->first;
int b = it->second;
dx.erase(dx.find(b - a));
dx.insert(p - a);
dx.insert(b - p);
setx.erase(it);
setx.insert({a, p});
setx.insert({p, b});
}
int main() {
scanf("%d%d%d", &w, &h, &n);
std::set<std::pair<int, int>> setx, sety;
std::multiset<int> dx, dy;
dx.insert(w);
dy.insert(h);
setx.insert({0, w});
sety.insert({0, h});
for (int i = 0; i < n; ++i) {
char op[2];
int p;
scanf("%s%d", op, &p);
if (op[0] == 'H') {
modify(sety, dy, p);
} else {
modify(setx, dx, p);
}
LL answer = 0;
answer = *--dx.end();
answer *= *--dy.end();
printf("%I64d\n", answer);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> a;
vector<long long> val, cnt;
vector<long long> dist;
vector<vector<int>> par;
void dfs(int x, int p) {
par[x][0] = p;
for (int i = 1; i < 25; ++i) par[x][i] = par[par[x][i - 1]][i - 1];
for (auto [u, w] : a[x]) {
if (u == p) continue;
dist[u] = dist[x] + w;
dfs(u, x);
cnt[x] += cnt[u];
}
int pr = x;
for (int i = 24; i >= 0; --i) {
if (dist[x] - dist[par[pr][i]] <= val[x]) {
pr = par[pr][i];
}
}
cnt[par[x][0]]++;
cnt[par[pr][0]]--;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
int n;
cin >> n;
a.resize(n + 5, vector<pair<int, int>>());
val.resize(n + 5);
cnt.resize(n + 5, 0);
dist.resize(n + 5, 0);
par.resize(n + 5, vector<int>(25, 0));
for (int i = 1; i <= n; ++i) cin >> val[i];
for (int i = 2; i <= n; ++i) {
int p, w;
cin >> p >> w;
a[i].push_back({p, w});
a[p].push_back({i, w});
}
dfs(1, 0);
for (int i = 1; i <= n; ++i) cout << cnt[i] << " ";
cout << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n, m, s;
cin >> n >> m;
if (n[0] != m[0])
s = "1";
else
s = "0";
for (int i = 1; i < n.length(); i++) {
if (n[i] != m[i])
s += "1";
else
s += "0";
}
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 510;
const long long MOD = 998244353;
int n, a[maxN], pos[maxN];
char type[maxN];
bool done[maxN];
long long f[maxN][maxN], res;
int main(){
ios_base::sync_with_stdio(false); cin.tie(nullptr);
cin >> n;
for(int i=1; i<=n; ++i){
cin >> type[i];
if (type[i] == '+') cin >> a[i]; else a[i] = -1;
pos[i] = i;
}
sort(pos+1, pos+n+1, [](int x, int y){return a[x] < a[y];});
res = 0;
for(int i=1; i<=n; ++i) done[i] = false;
for(int s=1; s<=n; ++s) if (a[pos[s]] != -1){
f[0][0] = 1;
for(int i=1; i<=n; ++i){
if (a[i] == -1){
f[i][0] = (f[i-1][0]*2 + f[i-1][1]) % MOD;
for(int j=1; j<=n; ++j) f[i][j] = (f[i-1][j] + f[i-1][j+1]) % MOD;
}
else if (pos[s] == i){
f[i][0] = 0;
for(int j=1; j<=n; ++j) f[i][j] = f[i-1][j-1];
}
else if (done[i]){
f[i][0] = f[i-1][0];
for(int j=1; j<=n; ++j) f[i][j] = (f[i-1][j] + f[i-1][j-1]) % MOD;
}
else for(int j=0; j<=n; ++j) f[i][j] = f[i-1][j]*2 % MOD;
if (i >= pos[s]) f[i][0] = 0;
}
done[pos[s]] = true;
for(int j=0; j<=n; ++j) res = (res + f[n][j]*a[pos[s]]) % MOD;
}
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch <= '9' && ch >= '0'; x = x * 10 + ch - 48, ch = getchar())
;
return x;
}
long long i, j, k, m, n, z, x, y, f[110][110][110], col[110], w[110][110], ans,
o;
inline void Mn(long long& a, long long b) {
if ((b < a || a == -1) && (b != -1)) a = b;
}
int main() {
for (n = read(), m = read(), k = read(), i = 1; i <= n; ++i) col[i] = read();
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j) w[i][j] = read();
memset(f, -1, sizeof f), f[1][1][col[1]] = 0;
if (!col[1])
for (i = 1; i <= m; ++i) f[1][1][i] = w[1][i];
for (i = 1; i < n; ++i) {
for (j = 1; j <= i; ++j)
for (o = 1; o <= m; ++o)
if (f[i][j][o] != -1) {
if (!col[i + 1]) {
for (z = 1; z <= m; ++z)
if (o != z)
Mn(f[i + 1][j + 1][z], f[i][j][o] + w[i + 1][z]);
else
Mn(f[i + 1][j][z], f[i][j][o] + w[i + 1][z]);
} else if (o != col[i + 1])
Mn(f[i + 1][j + 1][col[i + 1]], f[i][j][o]);
else
Mn(f[i + 1][j][col[i + 1]], f[i][j][o]);
}
}
for (ans = -1, i = 1; i <= m; ++i) Mn(ans, f[n][k][i]);
printf("%I64d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<int> f(n);
vector<int> f_map(n + 1, -1);
vector<int> f_map_amb(n + 1, -1);
for (int i = 0; i < n; i++) {
cin >> f[i];
if (f_map[f[i]] == -1)
f_map[f[i]] = i + 1;
else
f_map_amb[f[i]] = 1;
}
vector<int> b(m);
for (int i = 0; i < m; i++) cin >> b[i];
bool impos = false;
bool ambig = false;
for (int i = 0; i < m; i++) {
if (f_map[b[i]] == -1) {
impos = true;
break;
}
if (f_map_amb[b[i]] == 1) ambig = true;
}
if (impos)
cout << "Impossible" << endl;
else if (ambig)
cout << "Ambiguity" << endl;
else {
cout << "Possible" << endl;
for (int i = 0; i < m; i++) cout << f_map[b[i]] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000404;
const long long MOD = 1000000007ll;
const long double PI = acos(-1.0);
const long long INF = 2000000000000000000ll;
const long double EPS = 1e-9;
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
inline T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
inline bool pal(string &x) {
int n = (int)x.length();
for (int i = 0; i < n / 2; i++) {
if (x[i] != x[n - i - 1]) return 0;
}
return 1;
}
int month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int dx8[] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy8[] = {-1, 0, 1, 1, -1, -1, 0, 1};
int SQ = 400;
int a[123456];
set<int> s;
int n;
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
}
while (true) {
int x = *s.rbegin();
int temp = x;
while (x > 0) {
x >>= 1;
if (!s.count(x)) break;
}
if (x == 0) return;
s.erase(temp);
s.insert(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
};
for (auto x : s) cout << x << ' ';
getchar();
getchar();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 14;
int n, m, g[Maxn];
bool path[Maxn + 1][Maxn + 1][1 << Maxn | 1];
int pre[Maxn + 1][Maxn + 1][1 << Maxn | 1];
int dp[1 << Maxn | 1], last[1 << Maxn | 1][3];
int main(int argc, const char *argv[]) {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u] |= (1 << v);
g[v] |= (1 << u);
}
for (int u = 0; u < n; ++u)
for (int v = 0; v < n; ++v)
if (g[u] & (1 << v)) path[u][v][0] = 1, pre[u][v][0] = u;
for (int mask = 0; mask < (1 << n); ++mask)
for (int u = 0; u < n; ++u) {
if (mask & (1 << u)) continue;
for (int v = 0; v < n; ++v) {
if (mask & (1 << v)) continue;
if (u == v) continue;
if (!path[u][v][mask]) continue;
for (int to = 0; to < n; ++to)
if (g[v] & (1 << to)) {
if (mask & (1 << to)) continue;
if (to == pre[u][v][mask]) continue;
if (path[u][to][mask | (1 << v)]) continue;
path[u][to][mask | (1 << v)] = 1;
pre[u][to][mask | (1 << v)] = v;
}
}
}
__builtin_memset(dp, 0x3f, sizeof dp), dp[1] = 0;
for (int mask = 0; mask < (1 << n); ++mask)
for (int smask = mask; smask; smask = smask - 1 & mask) {
int pmask = smask ^ mask;
int cnt = __builtin_popcount(smask) + 1;
if (dp[pmask] + cnt >= dp[mask]) continue;
for (int u = 0; u < n; ++u) {
if (!(pmask & (1 << u))) continue;
for (int v = 0; v < n; ++v) {
if (!(pmask & (1 << v))) continue;
if (path[u][v][smask])
dp[mask] = dp[pmask] + cnt, last[mask][0] = smask,
last[mask][1] = u, last[mask][2] = v;
}
}
}
cout << dp[(1 << n) - 1] << endl;
int mask = (1 << n) - 1;
while (mask != 1) {
int pmask = last[mask][0], tmp;
int u = last[mask][1], v = last[mask][2];
for (mask ^= pmask; pmask; pmask ^= 1 << (v = tmp))
cout << (tmp = pre[u][v][pmask]) + 1 << ' ' << v + 1 << endl;
cout << u + 1 << ' ' << v + 1 << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 309;
int n, like[maxn][maxn], alex[maxn], res[maxn];
bool has[maxn] = {};
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int x;
scanf("%d", &x);
like[i][x] = j;
}
like[i][i] = 9998;
like[i][0] = 9999;
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
alex[i] = x;
}
for (int i = 1; i <= n; i++) {
has[i] = 1;
int j = 1;
for (j = 1; j <= n; j++)
if (has[alex[j]]) break;
for (int k = 1; k <= n; k++) {
if (k == alex[j]) {
for (int t = j + 1; t <= n; t++)
if (has[alex[t]]) {
if (like[k][alex[t]] < like[k][res[k]]) res[k] = alex[t];
break;
}
} else if (like[k][alex[j]] < like[k][res[k]])
res[k] = alex[j];
}
}
for (int i = 1; i <= n; i++) printf("%d ", res[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n + 2);
for (int i = 1; i <= n; i++) cin >> v[i];
int min_num = 1e9, max_num = -1e9, val, ans = 0;
for (int i = 1; i <= n; i++) {
if (v[i] != -1 && (v[i - 1] == -1 || v[i + 1] == -1))
min_num = min(min_num, v[i]), max_num = max(max_num, v[i]);
}
val = (min_num + max_num) / 2;
if (v[1] == -1) v[1] = val;
for (int i = 2; i <= n; i++) {
if (v[i] == -1) v[i] = val;
ans = max(ans, abs(v[i] - v[i - 1]));
}
cout << ans << ' ' << val << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
void Main();
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
Main();
}
pair<long long, long long> p[111];
const long long INF = 20200000000000000ll;
void Main() {
long long x0, y0, ax, ay, bx, by, xs, ys, t;
cin >> x0 >> y0 >> ax >> ay >> bx >> by >> xs >> ys >> t;
p[0] = {x0, y0};
int tot = 1;
for (int i = 1; true; i++) {
const long long nx = p[i - 1].first * ax + bx,
ny = p[i - 1].second * ay + by;
if (nx > INF || ny > INF) break;
p[i] = {nx, ny};
tot++;
}
int ans = 0;
for (int i = 0; i < tot; i++) {
long long dis = abs(p[i].first - xs) + abs(p[i].second - ys);
for (int j = 0; j < tot; j++) {
if (dis + abs(p[i].first - p[j].first) + abs(p[i].second - p[j].second) <=
t) {
ans = max(ans, 1 + abs(i - j));
}
}
}
cout << ans << "\n";
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.