solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
FILE *in;
FILE *out;
struct State {
int node, price;
State(int node_ = 0, int price_ = 0) : node(node_), price(price_){};
bool operator<(const State &r) const {
return price != r.price ? price > r.price : node < r.node;
}
};
int n, m;
vector<State> v[131072];
vector<int> times[131072];
priority_queue<State> q;
int vis[131072], best[131072];
int getPrice(int node, int atTime) {
if (times[node].size() == 0) return atTime;
int left, right, mid;
left = 0, right = (int)times[node].size() - 1;
int idx = (int)times[node].size();
while (left <= right) {
mid = (left + right) / 2;
if (times[node][mid] < atTime)
left = mid + 1;
else {
idx = mid;
right = mid - 1;
}
}
if (idx >= (int)times[node].size() || times[node][idx] > atTime)
return atTime;
left = idx, right = (int)times[node].size() - 1;
while (left <= right) {
mid = (left + right) / 2;
if (times[node][mid] - times[node][idx] == mid - idx) {
idx = mid;
left = mid + 1;
} else
right = mid - 1;
}
return times[node][idx] + 1;
}
int dijkstra(int startNode, int endNode) {
State cur, nxt;
memset(vis, 0, sizeof(vis));
memset(best, 127, sizeof(best));
nxt.node = startNode;
nxt.price = getPrice(startNode, 0);
q.push(nxt);
best[nxt.node] = nxt.price;
while (!q.empty()) {
cur = q.top();
q.pop();
if (vis[cur.node]) continue;
vis[cur.node] = 1;
if (cur.node == endNode) return cur.price;
for (int i = 0; i < (int)v[cur.node].size(); i++) {
nxt.node = v[cur.node][i].node;
if (!vis[nxt.node]) {
nxt.price = getPrice(nxt.node, cur.price + v[cur.node][i].price);
if (nxt.price < best[nxt.node]) {
best[nxt.node] = nxt.price;
q.push(nxt);
}
}
}
}
return -1;
}
int main(void) {
in = stdin;
out = stdout;
fscanf(in, "%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int node1, node2, price;
fscanf(in, "%d %d %d", &node1, &node2, &price);
node1--;
node2--;
v[node1].push_back(State(node2, price));
v[node2].push_back(State(node1, price));
}
for (int i = 0; i < n - 1; i++) {
int k;
fscanf(in, "%d", &k);
for (int c = 0; c < k; c++) {
int tmp;
fscanf(in, "%d", &tmp);
times[i].push_back(tmp);
}
}
fprintf(out, "%d\n", dijkstra(0, n - 1));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, answer = 1e17;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
if (i >= k) {
break;
}
if (n % i == 0) {
long long a, b;
b = i;
a = n / i;
a = a * k;
answer = min(answer, a + b);
}
}
cout << answer << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float num[4];
bool v = true;
cin >> num[0] >> num[1] >> num[2] >> num[3];
float a;
float t;
int k;
a = num[1] - num[0];
t = num[1] / num[0];
if (num[2] - num[1] == a && num[3] - num[2] == a) {
cout << num[3] + a << endl;
} else if (num[2] / num[1] == t && num[3] / num[2] == t) {
k = num[3] * t;
if (num[3] * t == k) {
cout << num[3] * t << endl;
} else {
cout << 42 << endl;
}
} else {
cout << 42 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100005] = {};
bool srt(const pair<int, int> &lhs, const pair<int, int> &rhs) {
return lhs.second > rhs.second;
}
int z[1000] = {};
int o[1000] = {};
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = n - 1; i >= 0; i--) {
o[i] = o[i + 1] + a[i];
}
if (a[0] == 0) z[0] = 1;
for (int i = 1; i < n; i++) {
if (a[i] == 0)
z[i] = z[i - 1] + 1;
else
z[i] = z[i - 1];
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, z[i] + o[i]);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int N = 1e5 + 10;
const int MX = 310;
int dp[N][MX], a[N], b[N];
vector<int> arr[N];
signed main() {
int n, m, s, e;
cin >> n >> m >> s >> e;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int j = 1; j <= m; j++) {
cin >> b[j];
arr[b[j]].push_back(j);
}
int MX = s / e;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= MX; j++) {
dp[i][j] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= MX; j++) {
if (dp[i][j] == INF) {
continue;
}
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
int ps = upper_bound((arr[a[i + 1]]).begin(), (arr[a[i + 1]]).end(),
dp[i][j]) -
arr[a[i + 1]].begin(),
vl;
if (ps == (int)(arr[a[i + 1]]).size()) {
vl = INF;
} else {
vl = arr[a[i + 1]][ps];
}
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], vl);
}
}
int ans = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= MX; j++) {
if (dp[i][j] < INF) {
if (e * j + i + dp[i][j] <= s) {
ans = max(ans, j);
}
}
}
}
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tos(T q, int w = 0) {
stringstream A;
A.flags(ios::fixed);
A.precision(w);
A << q;
string s;
A >> s;
return s;
}
template <typename T>
T sto(string s) {
stringstream A(s);
T t;
A >> t;
return t;
}
template <typename T>
vector<T> s2v(string s) {
stringstream A(s);
vector<T> ans;
while (A && !A.eof()) {
T t;
A >> t;
ans.push_back(t);
}
return ans;
}
int a[1000];
int main() {
int n, l;
cin >> n >> l;
for (int i = (0); i < (n); ++i) cin >> a[i];
int ans = 0;
for (int d = (l); d < (101); ++d) {
int h = 0;
for (int i = (0); i < (n); ++i) h += (a[i] / d);
ans = max(ans, d * h);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100005];
int i, n;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a, a + n);
cout << n / 2 + n % 2 << endl;
for (i = 0; i < n; i += 2) cout << a[i].second + 1 << " ";
cout << endl << n / 2 << endl;
for (i = 1; i < n; i += 2) cout << a[i].second + 1 << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[500000], n, i, ans;
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
sort(a + 2, a + n);
for (i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T, n, nums[100005];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> T;
while (T--) {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> nums[i];
sort(nums + 1, nums + 1 + n);
int p = n;
while (p >= 1) {
if (p >= nums[p]) break;
--p;
}
cout << p + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long lgg[600], n, k;
void dd(long long x, long long y) {
if (y == lgg[x]) {
cout << x + 1;
return;
}
y %= lgg[x];
dd(x - 1, y);
}
int main() {
lgg[0] = 1;
for (int i = 1; i <= 60; i++) {
lgg[i] = lgg[i - 1] * 2;
}
cin >> n >> k;
dd(n, k);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int modpow(long long int a, long long int n, long long int temp) {
long long int res = 1;
while (n > 0) {
res = (res * res) % temp;
if (n & 1) res = (res * a) % temp;
n /= 2;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (a == 0)
return (b);
else
return (gcd(b % a, a));
}
void f(int a[][1001], int x, int y) {
if (a[x][y] >= 4) {
int t = a[x][y] / 4;
a[x][y + 1] += t;
a[x + 1][y] += t;
a[x - 1][y] += t;
a[x][y - 1] += t;
a[x][y] = a[x][y] % 4;
f(a, x + 1, y);
f(a, x - 1, y);
f(a, x, y + 1);
f(a, x, y - 1);
}
}
int main() {
int a[1001][1001] = {0};
int n, q, x, y;
cin >> n >> q;
a[500][500] = n;
f(a, 500, 500);
while (q--) {
cin >> x >> y;
x += 500;
y += 500;
if (x > 1000 || y > 1000 || x < 0 || y < 0)
cout << 0 << endl;
else
cout << a[x][y] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int readint() {
int t = 0;
char c, ch;
ch = getchar();
if (ch == '-')
c = getchar();
else
c = ch;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
t = (t << 3) + (t << 1) + c - '0';
c = getchar();
}
if (ch == '-')
return -t;
else
return t;
}
vector<vector<int> > pairs(2010);
int vis[2010], maxi = -1, f = 0;
int dfs(int x) {
int i, p = 0;
vis[x] = 1;
for (i = 0; i <= (int)pairs[x].size() - 1; i++) {
if (!vis[pairs[x][i]]) {
int a = dfs(pairs[x][i]);
p = (p) > (a) ? (p) : (a);
}
}
return 1 + p;
}
int main() {
int i, j, k, n, m, y;
cin >> n;
for (i = 1; i <= n; i++) {
int x;
cin >> x;
if (x != -1) pairs[x].push_back(i);
}
for (i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
;
y = dfs(i);
maxi = (maxi) > (y) ? (maxi) : (y);
}
cout << maxi << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
int power(int a, int b, int mod, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % mod)
if (b & 1) ans = 1LL * ans * a % mod;
return ans;
}
const int mod = 1e9 + 7;
int a[555], b[555];
int main() {
int n;
scanf("%d", &n);
INT ans = power(2, n - 1, mod) - 1;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
if (~a[i]) b[a[i]]++;
}
for (int i = 1; i <= n; i++) ans -= power(2, b[i], mod) - 1;
ans = (ans % mod + mod) % mod;
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void next_p(long long a1, long long b1, long long x1, long long y1,
long long& x2, long long& y2) {
x2 = a1 - 1 * (y1 - b1);
y2 = b1 + x1 - a1;
}
bool quadrado(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3, long long x4, long long y4) {
long long d12 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
long long d13 = (x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3);
long long d14 = (x1 - x4) * (x1 - x4) + (y1 - y4) * (y1 - y4);
long long d23 = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
long long d24 = (x2 - x4) * (x2 - x4) + (y2 - y4) * (y2 - y4);
long long d34 = (x3 - x4) * (x3 - x4) + (y3 - y4) * (y3 - y4);
if (d12 == 0 || d13 == 0 || d14 == 0 || d23 == 0 || d24 == 0 || d34 == 0) {
return false;
}
if (d14 > d12 and d12 == d13) {
return (d12 == d24 and d24 == d34 and d14 == d23);
} else if (d12 > d13 and d13 == d14) {
return (d13 == d23 and d23 == d24 and d12 == d34);
} else if (d13 > d12 and d12 == d14) {
return (d12 == d23 and d12 == d34 and d13 == d24);
}
return false;
}
int main() {
ios::sync_with_stdio(false);
long long n, m, x, mov, min_mov;
long long x1, y1, a1, b1;
long long x2, y2, a2, b2;
long long x3, y3, a3, b3;
long long x4, y4, a4, b4;
cin >> n;
for (long long c = 1; c <= n; c++) {
cin >> x1 >> y1 >> a1 >> b1;
cin >> x2 >> y2 >> a2 >> b2;
cin >> x3 >> y3 >> a3 >> b3;
cin >> x4 >> y4 >> a4 >> b4;
min_mov = 1000000;
for (long long i = 0; i < 4; i++) {
for (long long j = 0; j < 4; j++) {
for (long long k = 0; k < 4; k++) {
for (long long l = 0; l < 4; l++) {
if (quadrado(x1, y1, x2, y2, x3, y3, x4, y4)) {
mov = i + j + k + l;
min_mov = min(min_mov, mov);
}
next_p(a4, b4, x4, y4, x4, y4);
}
next_p(a3, b3, x3, y3, x3, y3);
}
next_p(a2, b2, x2, y2, x2, y2);
}
next_p(a1, b1, x1, y1, x1, y1);
}
if (min_mov == 1000000)
cout << "-1" << endl;
else
cout << min_mov << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], p[maxn], dp[maxn];
int n, m;
bool check(int len) {
memset(dp, 0, sizeof(dp));
dp[1] = 0;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1];
if (dp[i - 1] >= p[i] - len - 1) {
dp[i] = p[i];
if (dp[i - 1] >= p[i] - 1) dp[i] = p[i] + len;
}
if (i > 2 && dp[i - 2] >= p[i] - len - 1)
dp[i] = max(dp[i], p[i - 1] + len);
}
if (dp[n] >= m - len - 1) return 1;
dp[2] = max(len, p[2]);
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1];
if (dp[i - 1] >= p[i] - len - 1) {
dp[i] = p[i];
if (dp[i - 1] >= p[i] - 1) dp[i] = p[i] + len;
}
if (i > 2 && dp[i - 2] >= p[i] - len - 1)
dp[i] = max(dp[i], p[i - 1] + len);
}
if (dp[n] >= m - len - 1 + p[2]) return 1;
return 0;
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) a[i + n] = a[i] + m;
int len = 0;
for (int i = 1; i <= n; i++) len = max(len, a[i + 1] - a[i] - 1);
for (int i = 1; i <= n; i++) {
if (len != a[i + 1] - a[i] - 1) continue;
for (int j = 1; j <= n; j++) p[j] = a[i + j];
for (int j = n; j >= 1; j--) p[j] = p[j] - p[1];
break;
}
int l = (len + 1) / 2, r = m, ans = m;
while (l <= r) {
int mid = l + r >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%d\n", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[200050];
int st[200050];
int L[200050], R[200050];
int f[200050];
int main() {
int n;
cin >> n;
int t = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
while (t > 0 && a[st[t - 1]] >= a[i]) t--;
L[i] = t == 0 ? 1 : (st[t - 1] + 1);
st[t++] = i;
}
t = 0;
for (int i = n; i >= 1; --i) {
while (t > 0 && a[st[t - 1]] >= a[i]) t--;
R[i] = t == 0 ? n + 1 : (st[t - 1]);
st[t++] = i;
}
for (int i = 1; i <= n; i++) {
f[R[i] - L[i]] = max(a[i], f[R[i] - L[i]]);
}
int big = f[n];
for (int i = n - 1; i >= 1; --i) {
if (!f[i])
f[i] = big;
else
f[i] = max(f[i], big), big = f[i];
}
for (int i = 1; i <= n; i++) printf("%d ", f[i]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, ans;
int main() {
cin >> n >> a >> b >> c;
for (int i = 0; i <= c; i++) {
for (int j = 0; j <= b; j++) {
int x = n - i * 2 - j;
if (x >= 0 && a * 0.5 >= x) ans++;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int power(int a, int b, int c, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % c)
if (b & 1) ans = (long long)ans * a % c;
return ans;
}
template <class T>
inline void smax(T &first, const T &second) {
if (first < second) first = second;
}
using pdd = pair<double, double>;
pdd p[101010], ori[101010], q[101010];
int nn, first[101010], second[101010];
double dist(const int &first, const int &second, const double &x1,
const double &y1) {
return sqrt((first - x1) * (first - x1) + (second - y1) * (second - y1));
}
const double eps = 1e-10;
int sgn(const double &x1, const double &y1, const double &x2,
const double &y2) {
double s = x1 * y2 - y1 * x2;
return (s > eps) - (s < -eps);
}
pdd calc(const pdd &a, const pdd &b, const pdd &c, const pdd &d) {
double t = ((b.first - a.first) * (c.second - a.second) -
(b.second - a.second) * (c.first - a.first)) /
((b.first - a.first) * d.second - (b.second - a.second) * d.first);
return make_pair(c.first - t * d.first, c.second - t * d.second);
}
void cut(double x1, double y1, double x2, double y2) {
if (!nn) return;
int m = 0, pre = sgn(x2, y2, p[0].first - x1, p[0].second - y1);
p[nn] = p[0];
for (int i = 0; i < nn; i++) {
int now = sgn(x2, y2, p[i + 1].first - x1, p[i + 1].second - y1);
if (!now)
q[m++] = p[i + 1];
else if (!pre) {
if (now > 0) q[m++] = p[i + 1];
} else if (pre > 0) {
if (now < 0)
q[m++] = calc(p[i], p[i + 1], make_pair(x1, y1), make_pair(x2, y2));
else
q[m++] = p[i + 1];
} else {
if (now > 0) {
q[m++] = calc(p[i], p[i + 1], make_pair(x1, y1), make_pair(x2, y2));
q[m++] = p[i + 1];
}
}
pre = now;
}
nn = m;
for (int i = 0; i < nn; i++) p[i] = q[i];
}
int main() {
int w, h, n;
cin >> w >> h >> n;
for (int i = 0; i < n; i++) scanf("%d%d", first + i, second + i);
double ans = 0;
for (int i = 0; i < n; i++) {
nn = 0;
p[nn++] = make_pair(0, 0);
p[nn++] = make_pair(w, 0);
p[nn++] = make_pair(w, h);
p[nn++] = make_pair(0, h);
int ok = 0;
for (int j = 0; j < n; j++)
if (i != j) {
if (first[i] == first[j] && second[i] == second[j]) {
ok = 1;
continue;
}
cut((first[i] + first[j]) * 0.5, (second[i] + second[j]) * 0.5,
-(second[j] - second[i]), first[j] - first[i]);
}
if (ok) {
for (int j = 0; j < nn; j++)
smax(ans, dist(first[i], second[i], p[j].first, p[j].second));
continue;
}
vector<int> id;
p[nn] = p[0];
for (int j = 0; j < nn; j++) {
int ii = -1;
double cur = 1e100, tmp;
double xx = (p[j].first + p[j + 1].first) / 2,
yy = (p[j].second + p[j + 1].second) / 2;
for (int k = 0; k < n; k++)
if (k != i) {
if (first[k] == first[i] && second[k] == second[i]) continue;
if ((tmp = dist(first[k], second[k], xx, yy)) < cur)
cur = tmp, ii = k;
}
id.emplace_back(ii);
}
sort(id.begin(), id.end());
id.resize(unique(id.begin(), id.end()) - id.begin());
int m = nn;
for (int j = 0; j < nn; j++) ori[j] = p[j];
for (int j : id) {
nn = m;
for (int k = 0; k < m; k++) p[k] = ori[k];
for (int k : id)
if (j != k) {
cut((first[j] + first[k]) * 0.5, (second[j] + second[k]) * 0.5,
-(second[k] - second[j]), first[k] - first[j]);
}
for (int k = 0; k < nn; k++)
smax(ans, dist(first[j], second[j], p[k].first, p[k].second));
}
}
cout << fixed << setprecision(20) << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, x, y, z, p;
int xx, yy;
string s;
cin >> n >> m >> x >> y >> z >> p;
int arr[p][2];
for (int k = 0; k < p; ++k) {
cin >> i >> j;
arr[k][0] = i;
arr[k][1] = j;
}
x %= 4;
y %= 2;
z %= 4;
while (x--) {
for (int i = 0; i < p; ++i) {
xx = arr[i][0];
yy = arr[i][1];
arr[i][0] = yy;
arr[i][1] = n - xx + 1;
}
swap(n, m);
}
while (y--) {
for (int i = 0; i < p; ++i) {
arr[i][1] = m + 1 - arr[i][1];
}
}
for (int j = 0; j < 4 - z; j++) {
for (int i = 0; i < p; ++i) {
xx = arr[i][0];
yy = arr[i][1];
arr[i][0] = yy;
arr[i][1] = n - xx + 1;
}
swap(n, m);
}
for (int i = 0; i < p; ++i) cout << arr[i][0] << " " << arr[i][1] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
vector<int> a[N], b[N];
int pi[N], pj[N];
vector<int> v;
int main() {
int n, m, f, i, j, x, t;
cin >> n >> m;
if (n == 3 && m == 3) {
cout << "YES\n";
cout << "5 7 3\n";
cout << "9 2 4\n";
cout << "1 6 8\n";
return 0;
}
if (n == 1 && m == 1) {
cout << "YES\n";
cout << "1\n";
return 0;
}
if (n <= 3 && m <= 3) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
if (m <= 3) {
swap(n, m);
f = 1;
} else
f = 0;
for (i = 1; i <= n; i = i + 1)
for (j = 0; j <= m; j = j + 1) a[i].push_back((i - 1) * m + j);
if (m > 3) {
for (i = 1; i <= n; i = i + 1) {
t = 0;
for (j = 1; j <= m; j = j + 1) {
x = a[i][j];
if (x % 2 == 0) pi[x] = i, pj[x] = ++t;
}
for (j = 1; j <= m; j = j + 1) {
x = a[i][j];
if (x % 2 == 1) pi[x] = i, pj[x] = ++t;
}
if (m % 2 == 0 && i % 2 == 0) {
for (j = 1; j <= m; j = j + 1) {
x = a[i][j];
pj[x] = m + 1 - pj[x];
}
}
}
}
if (f) swap(n, m);
for (i = 1; i <= n; i = i + 1) b[i].resize(m + 1);
if (!f) {
for (i = 1; i <= n; i = i + 1)
for (j = 1; j <= m; j = j + 1) x = (i - 1) * m + j, b[pi[x]][pj[x]] = x;
} else {
for (i = 1; i <= n; i = i + 1)
for (j = 1; j <= m; j = j + 1)
x = (i - 1) * m + j, t = (j - 1) * n + i, b[pj[t]][pi[t]] = x;
}
for (i = 1; i <= n; i = i + 1) {
for (j = 1; j <= m; j = j + 1) cout << b[i][j] << ' ';
cout << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int neg = 0, pos = 0;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
if (a < 0)
neg += a;
else
pos += a;
}
cout << (pos - neg);
return 0;
}
| 0 |
#include <bits/stdc++.h>
std::vector<long long> gv(long long n) {
std::vector<long long> v(n);
for (auto &x : v) {
std::cin >> x;
}
return v;
}
using namespace std;
long long ROW[] = {+0, +0, -1, +1};
long long COL[] = {+1, -1, +0, +0};
long long X[] = {+0, +0, +1, -1, -1, +1, -1, +1};
long long Y[] = {-1, +1, +0, +0, +1, +1, -1, -1};
long long KX[] = {-2, -2, -1, -1, 1, 1, 2, 2};
long long KY[] = {-1, 1, -2, 2, -2, 2, -1, 1};
long long binpow(long long a, long long b, long long m = (long long)1e18 + 7) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
void solve() {
long long n;
cin >> n;
long long ans = 6 * binpow(4, n - 2) + (n - 3) * 9 * binpow(4, n - 3);
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
long long t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int get(int first, int second) {
vector<int> d(10);
while (first) {
d[first % 10] = 1;
first /= 10;
}
while (second) {
if (d[second % 10] == 1) {
return 1;
}
second /= 10;
}
return 0;
}
void solve() {
int first;
cin >> first;
int ans = 0;
for (int i = 1; i * i <= first; ++i) {
if (first % i == 0) {
ans += get(first, i);
if (first / i != i) {
ans += get(first, first / i);
}
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, arr[60];
memset(&arr, 0, sizeof(arr));
arr[0] = 1;
arr[1] = 1;
for (i = 2; i * i < 60; i++) {
if (arr[i]) continue;
for (j = i * i; j < 60; j = j + i) arr[j] = i;
}
int n, m;
cin >> n >> m;
for (i = n + 1; i < 60; i++)
if (!arr[i]) break;
if (i == m)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
int c[maxn], k[maxn];
int _count[maxn];
int n, m, tot;
bool judge(int s) {
memset(_count, 0, sizeof(_count));
for (int i = s; i < s + tot; i++) {
_count[c[i]]++;
}
for (int i = 1; i <= n; i++) {
if (_count[i] != k[i]) {
return false;
}
}
return true;
}
int main(void) {
tot = 0;
scanf("%d %d", &n, &m);
memset(k, 0, sizeof(k));
for (int i = 0; i < n; i++) {
scanf("%d", c + i);
}
for (int i = 1; i <= m; i++) {
scanf("%d", k + i);
tot += k[i];
}
for (int i = 0; i <= n - tot; i++) {
if (judge(i)) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, fl;
int main() {
scanf("%d%d", &m, &n);
if (n == 1) return printf("%d", -1), 0;
if (n == 2 && m == 3) return printf("%d", 11), 0;
if (n == 3 && m == 5) return printf("%d", 11), 0;
for (;;) {
if (n >= m + m) return printf("%d", ans + 1), 0;
if (n >= m) return printf("%d", ans + 3 + 2 * (n == m)), 0;
if (!fl)
m -= n - 2, ans = 4, fl = 1;
else if (n / 2 == 1)
return printf("%d", -1), 0;
else
m -= n / 2 - 1, ans += 2;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y;
Point() {}
Point(long long a, long long b) : x(a), y(b) {}
Point operator-(Point b) { return Point(x - b.x, y - b.y); }
};
inline long double cross(Point x, Point y) {
return (long double)x.x * y.y - (long double)x.y * y.x;
}
inline long long calc(Point x, long long k) { return x.x * k + x.y; }
int SIZE, n;
int addv[505], minn[505];
int vala[200005], valb[200005];
int id[505][505];
int size1[505], size2[505], pt1[505], pt2[505];
Point hull1[505][505], hull2[505][505];
void rebuild(int x) {
int l = (x - 1) * SIZE + 1, r = min(n, x * SIZE), len = r - l + 1;
Point *p = hull1[x], *q = hull2[x];
int top1 = 0, top2 = 0;
minn[x] = 0x7f7f7f7f;
for (int i = 1; i <= len; i++) {
int u = id[x][i];
vala[u] += addv[x];
if (vala[u] >= 0) {
Point t(valb[u], (long long)vala[u] * valb[u]);
while (top1 > 1 && cross(t - p[top1], p[top1] - p[top1 - 1]) <= 0) top1--;
p[++top1] = t;
} else {
minn[x] = min(minn[x], -vala[u]);
Point t(valb[u], -(long long)vala[u] * valb[u]);
while (top2 > 1 && cross(t - q[top2], q[top2] - q[top2 - 1]) <= 0) top2--;
q[++top2] = t;
}
}
size1[x] = top1;
pt1[x] = 1;
size2[x] = top2;
pt2[x] = top2;
addv[x] = 0;
}
long long querybl(int x) {
int t = addv[x];
while (pt1[x] < size1[x] &&
calc(hull1[x][pt1[x]], t) < calc(hull1[x][pt1[x] + 1], t))
pt1[x]++;
while (pt2[x] > 1 &&
calc(hull2[x][pt2[x]], -t) < calc(hull2[x][pt2[x] - 1], -t))
pt2[x]--;
long long ans = 0;
if (size1[x]) ans = max(ans, calc(hull1[x][pt1[x]], t));
if (size2[x]) ans = max(ans, calc(hull2[x][pt2[x]], -t));
return ans;
}
void update(int l, int r, int v) {
int lb = (l - 1) / SIZE + 1, rb = (r - 1) / SIZE + 1;
if (lb == rb) {
for (int i = l; i <= r; i++) vala[i] += v;
rebuild(lb);
} else {
int t = min(lb * SIZE, n);
for (int i = l; i <= t; i++) vala[i] += v;
rebuild(lb);
t = (rb - 1) * SIZE + 1;
for (int i = t; i <= r; i++) vala[i] += v;
rebuild(rb);
for (int i = lb + 1; i < rb; i++) {
addv[i] += v;
if (minn[i] < addv[i]) rebuild(i);
}
}
}
long long query(int l, int r) {
int lb = (l - 1) / SIZE + 1, rb = (r - 1) / SIZE + 1;
long long ans = 0;
if (lb == rb) {
for (int i = l; i <= r; i++)
ans = max(ans, (long long)abs(vala[i] + addv[lb]) * valb[i]);
} else {
int t = min(lb * SIZE, n);
for (int i = l; i <= t; i++)
ans = max(ans, (long long)abs(vala[i] + addv[lb]) * valb[i]);
t = (rb - 1) * SIZE + 1;
for (int i = t; i <= r; i++)
ans = max(ans, (long long)abs(vala[i] + addv[rb]) * valb[i]);
for (int i = lb + 1; i < rb; i++) ans = max(ans, querybl(i));
}
return ans;
}
vector<int> e[200005];
int dfn[200005], end2[200005], dfs_cnt;
int p[200005];
void dfs(int x) {
dfn[x] = ++dfs_cnt;
for (int i = 0; i < e[x].size(); i++) dfs(e[x][i]);
end2[x] = dfs_cnt;
}
bool cmp(int x, int y) { return valb[x] < valb[y]; }
int main() {
int m;
scanf("%d%d", &n, &m);
SIZE = max(1, (int)sqrt(n));
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
e[p[i]].push_back(i);
}
dfs(1);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
vala[dfn[i]] = vala[dfn[p[i]]] + x;
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
valb[dfn[i]] = valb[dfn[p[i]]] + x;
}
for (int i = 1; i <= n; i++) valb[i] = abs(valb[i]);
for (int i = 1; i <= n; i++) {
int t = (i - 1) / SIZE + 1;
id[t][++id[t][0]] = i;
}
for (int i = 1; (i - 1) * SIZE < n; i++) {
sort(id[i] + 1, id[i] + id[i][0] + 1, cmp);
rebuild(i);
}
for (int i = 1; i <= m; i++) {
int kind;
scanf("%d", &kind);
if (kind == 1) {
int x, y;
scanf("%d%d", &x, &y);
update(dfn[x], end2[x], y);
} else {
int x;
scanf("%d", &x);
printf("%lld\n", query(dfn[x], end2[x]));
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long aux;
cin >> aux;
long long aux2;
long long ultimo = 2 << 30;
long long cont = 0;
long long cont2 = 0;
long long cont3 = 0;
long long comeco = 0;
for (long long i = 0; i < aux; i++) {
cin >> aux2;
if (aux2 == ultimo) {
cont3++;
cont2 = cont2 + cont3;
} else {
cont = cont + cont2;
cont2 = 1;
cont3 = 1;
ultimo = aux2;
}
}
cont = cont + cont2;
cout << cont;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2007;
const int mod = 1e9 + 7;
int n, m;
int dp[maxn][maxn][2], block[maxn][maxn][2], sum[maxn][maxn][2], vec[maxn][2];
char s[maxn][maxn];
int calc(int u, int v, int w) {
if (w == 0) {
for (; vec[v][1] < u; ++vec[v][1]) {
if (block[vec[v][1] + 1][v][1] <= n - u) break;
}
return (sum[u - 1][v][1] - sum[vec[v][1] - 1][v][1] + mod) % mod;
} else {
for (; vec[u][0] < v; ++vec[u][0]) {
if (block[u][vec[u][0] + 1][0] <= m - v) break;
}
return (sum[u][v - 1][0] - sum[u][vec[u][0] - 1][0] + mod) % mod;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
if (n == 1 && m == 1) {
cout << 1 << endl;
return 0;
}
for (int i = 1; i <= max(n, m); ++i) {
vec[i][0] = vec[i][1] = 1;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> s[i][j];
if (s[i][j] == 'R') block[i + 1][j + 1][0] = block[i + 1][j + 1][1] = 1;
}
}
for (int i = 0; i <= n; ++i) {
for (int j = m; j > 0; --j) {
block[i][j - 1][0] += block[i][j][0];
}
}
for (int j = 0; j <= m; ++j) {
for (int i = n; i > 0; --i) {
block[i - 1][j][1] += block[i][j][1];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (i == 0 && j == 0) {
dp[0][0][0] = dp[0][0][1] = 1;
sum[1][1][0] = sum[1][1][1] = 1;
continue;
}
dp[i][j][0] = calc(i + 1, j + 1, 0);
dp[i][j][1] = calc(i + 1, j + 1, 1);
sum[i + 1][j + 1][0] = (sum[i + 1][j][0] + dp[i][j][0]) % mod;
sum[i + 1][j + 1][1] = (sum[i][j + 1][1] + dp[i][j][1]) % mod;
}
}
printf("%d\n", (dp[n - 1][m - 1][0] + dp[n - 1][m - 1][1]) % mod);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n;
int son[N][2];
int type[N], val[N], f[N];
inline void dfs(int x) {
if (type[x] == 4) return;
int s0 = son[x][0], s1 = son[x][1];
if (type[x] == 3) dfs(s0), val[x] = (val[s0] ^ 1);
if (type[x] == 2) dfs(s0), dfs(s1), val[x] = (val[s0] ^ val[s1]);
if (type[x] == 1) dfs(s0), dfs(s1), val[x] = (val[s0] | val[s1]);
if (type[x] == 0) dfs(s0), dfs(s1), val[x] = (val[s0] & val[s1]);
}
inline void dfs2(int x) {
if (type[x] == 4) return;
int s0 = son[x][0], s1 = son[x][1];
if (type[x] == 3) {
f[s0] = f[x];
dfs2(s0);
}
if (type[x] == 2) {
if (((val[s0] ^ 1) ^ val[s1]) != val[x])
f[s0] = f[x];
else
f[s0] = val[1];
if (((val[s1] ^ 1) ^ val[s0]) != val[x])
f[s1] = f[x];
else
f[s1] = val[1];
dfs2(s0), dfs2(s1);
}
if (type[x] == 1) {
if (((val[s0] ^ 1) | val[s1]) != val[x])
f[s0] = f[x];
else
f[s0] = val[1];
if (((val[s1] ^ 1) | val[s0]) != val[x])
f[s1] = f[x];
else
f[s1] = val[1];
dfs2(s0), dfs2(s1);
}
if (type[x] == 0) {
if (((val[s0] ^ 1) & val[s1]) != val[x])
f[s0] = f[x];
else
f[s0] = val[1];
if (((val[s1] ^ 1) & val[s0]) != val[x])
f[s1] = f[x];
else
f[s1] = val[1];
dfs2(s0), dfs2(s1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
char s[9];
scanf("%s", s);
int x, y;
if (s[0] == 'A')
type[i] = 0, scanf("%d%d", &x, &y), son[i][0] = x, son[i][1] = y;
if (s[0] == 'O')
type[i] = 1, scanf("%d%d", &x, &y), son[i][0] = x, son[i][1] = y;
if (s[0] == 'X')
type[i] = 2, scanf("%d%d", &x, &y), son[i][0] = x, son[i][1] = y;
if (s[0] == 'N') type[i] = 3, scanf("%d", &x), son[i][0] = x;
if (s[0] == 'I') type[i] = 4, scanf("%d", &x), val[i] = x;
}
dfs(1);
f[1] = val[1] ^ 1;
dfs2(1);
for (int i = 1; i <= n; i++)
if (type[i] == 4) printf("%d", f[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int INF = INT_MAX;
const int MAX_N = 50005;
template <typename T>
inline T sqr(T a) {
return a * a;
};
bool is_leap(int year) {
return ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0));
}
int main(int argc, char const *argv[]) {
int y, cnt = 0;
bool flag;
cin >> y;
flag = is_leap(y);
do cnt = (cnt + 365 + is_leap(y++)) % 7;
while (cnt % 7 || (flag != is_leap(y)));
cout << y << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename C, typename T = decay<decltype(*begin(declval<C>()))>,
typename enable_if<!is_same<C, string>::value>::type * = nullptr>
ostream &operator<<(ostream &os, const C &c) {
bool f = true;
os << "[";
for (const auto &x : c) {
if (!f) os << ", ";
f = false;
os << x;
}
return os << "]";
}
template <typename T>
void debug(string s, T x) {
cerr << s << " = " << x << "\n";
}
template <typename T, typename... Args>
void debug(string s, T x, Args... args) {
cerr << s.substr(0, s.find(',')) << " = " << x << " | ";
debug(s.substr(s.find(',') + 2), args...);
}
template <int MOD>
struct ModInt {
long long v;
ModInt(long long _v = 0) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) v += MOD;
}
ModInt &operator+=(const ModInt &other) {
v += other.v;
if (v >= MOD) v -= MOD;
return *this;
}
ModInt &operator-=(const ModInt &other) {
v -= other.v;
if (v < 0) v += MOD;
return *this;
}
ModInt &operator*=(const ModInt &other) {
v = v * other.v % MOD;
return *this;
}
ModInt &operator/=(const ModInt &other) { return *this *= inverse(other); }
bool operator==(const ModInt &other) const { return v == other.v; }
bool operator!=(const ModInt &other) const { return v != other.v; }
friend ModInt operator+(ModInt a, const ModInt &b) { return a += b; }
friend ModInt operator-(ModInt a, const ModInt &b) { return a -= b; }
friend ModInt operator*(ModInt a, const ModInt &b) { return a *= b; }
friend ModInt operator/(ModInt a, const ModInt &b) { return a /= b; }
friend ModInt operator-(const ModInt &a) { return 0 - a; }
friend ModInt power(ModInt a, long long b) {
ModInt ret(1);
while (b > 0) {
if (b & 1) ret *= a;
a *= a;
b >>= 1;
}
return ret;
}
friend ModInt inverse(ModInt a) { return power(a, MOD - 2); }
friend ostream &operator<<(ostream &os, const ModInt &m) { return os << m.v; }
};
int c[300005];
ModInt<998244353> pref[300005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> c[i];
sort(c, c + n, greater<int>());
for (int i = 0; i < n; i++) pref[i + 1] = pref[i] + c[i];
ModInt<998244353> inv = inverse(ModInt<998244353>(n));
for (int k = 1; k <= n; k++) {
ModInt<998244353> ret;
for (int i = 0, j = 0; i < n; i += k, j++)
ret += j * (pref[min(n, i + k)] - pref[i]);
cout << ret * inv << " ";
}
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct ass {
int value;
int pos;
};
bool comp(ass a, ass b) { return a.value < b.value; }
int main() {
int n, k;
cin >> n >> k;
ass *a = new ass[n];
int max = 0;
int min = 1000000;
for (int i = 0; i < n; i++) {
cin >> a[i].value;
if (max < a[i].value) max = a[i].value;
if (min > a[i].value) min = a[i].value;
a[i].pos = i;
}
sort(a, a + n, comp);
int **b = new int *[n];
for (int i = 0; i < n; i++) {
b[i] = new int[a[i].value + 1];
}
int z = max - min;
int f = n;
if (z <= k) {
cout << "YES" << endl;
int v = 0;
int p = 0;
int l = 0;
while (n != 0) {
l = 0;
int m = 1;
b[v][0] = a[v].pos;
for (int i = 0; i <= a[v].value; i++) {
if (i == 0) {
for (int j = 1; j <= min; j++) {
b[v][j] = m;
i = j + 1;
}
if (v != 0) {
b[v][i] = 1;
i++;
m++;
}
}
if (i > a[v].value) {
break;
}
if (1 == l) {
l = 0;
m++;
}
b[v][i] = m;
l++;
}
n--;
v++;
}
int m = 0;
for (int x = 0; x < f; x++) {
while (x != b[m][0]) {
m++;
}
for (int i = 1; i <= a[m].value; i++) {
cout << b[m][i] << " ";
}
cout << endl;
m = 0;
}
} else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int len, a[100005], tot, n, cnt[20005], b[100005];
void init() {
scanf("%d", &len);
int x;
for (int i = 1; i <= len; i++) {
scanf("%d", &a[i]);
if (!a[i]) tot++;
}
}
void work() {
n = len;
int i, j;
if (n == 1) {
puts("0");
return;
}
if (tot == n) {
puts("0");
return;
}
if (n == 2) {
if (!a[1])
puts("1");
else
puts("0");
return;
}
if (n == 3) {
if (!tot) {
if (a[2] * a[2] == a[1] * a[3])
puts("0");
else
puts("1");
}
if (tot == 1) puts("1");
if (tot == 2) {
if (a[1])
puts("0");
else
puts("1");
}
return;
}
if (tot == n - 1) {
if (a[1])
puts("0");
else
puts("1");
return;
}
if (tot == n - 2) {
if (a[1])
puts("1");
else
puts("2");
return;
}
if (tot >= 2) {
puts("2");
return;
}
if (tot == 1) {
if (n <= 3) {
puts("1");
return;
}
for (i = 1; i <= n; i++)
if (a[i])
b[i] = a[i];
else
break;
for (i++; i <= n; i++) b[i - 1] = a[i];
for (i = 2; i < n - 1; i++)
if (b[i] * b[i] != b[i - 1] * b[i + 1]) {
puts("2");
return;
}
puts("1");
return;
}
for (i = 2; i < n; i++)
if (a[i] * a[i] != a[i - 1] * a[i + 1]) break;
if (i == n) {
puts("0");
return;
}
if (n <= 10) {
for (i = 1; i <= n; i++) {
b[0] = 0;
for (j = 1; j <= n; j++)
if (j != i) b[++b[0]] = a[j];
for (j = 2; j < n - 1; j++)
if (b[j] * b[j] != b[j - 1] * b[j + 1]) break;
if (j == n - 1) {
puts("1");
return;
}
}
puts("2");
return;
}
for (j = 3; j < n; j++)
if (a[j] * a[j] != a[j - 1] * a[j + 1]) break;
if (j == n) {
puts("1");
return;
}
for (j = 2; j < n - 1; j++)
if (a[j] * a[j] != a[j - 1] * a[j + 1]) break;
if (j == n - 1) {
puts("1");
return;
}
for (i = 2; i <= n; i++)
if (!(a[i] % a[i - 1])) cnt[a[i] / a[i - 1] + 10000]++;
for (i = 0; i <= 20000; i++)
if (cnt[i] >= n - 3) {
b[1] = a[1];
for (j = 2; j <= n; j++)
if (a[j] % a[j - 1] || a[j] / a[j - 1] != i - 10000)
break;
else
b[j] = a[j];
for (j++; j <= n; j++) b[j - 1] = a[j];
for (j = 2; j < n - 1; j++)
if (b[j] * b[j] != b[j - 1] * b[j + 1]) break;
if (j == n - 1) {
puts("1");
return;
}
puts("2");
return;
}
for (i = 0; i <= 20000; i++) cnt[i] = 0;
reverse(a + 1, a + n + 1);
for (i = 2; i <= n; i++)
if (!(a[i] % a[i - 1])) cnt[a[i] / a[i - 1] + 10000]++;
for (i = 0; i <= 20000; i++)
if (cnt[i] >= n - 3) {
b[1] = a[1];
for (j = 2; j <= n; j++)
if (a[j] % a[j - 1] || a[j] / a[j - 1] != i - 10000)
break;
else
b[j] = a[j];
for (j++; j <= n; j++) b[j - 1] = a[j];
for (j = 2; j < n - 1; j++)
if (b[j] * b[j] != b[j - 1] * b[j + 1]) break;
if (j == n - 1) {
puts("1");
return;
}
puts("2");
return;
}
puts("2");
return;
}
int main() {
init();
work();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int walk[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
const char dir[4] = {'L', 'U', 'R', 'D'};
int Vx, Vy, Sx, Sy, M, lastd_array[205][205];
bool tree_array[205][205];
list<int> dlist;
list<char> ans;
void Bfs() {
static int fx[42000], fy[42000];
int st(0), en(0);
fx[0] = Vx, fy[0] = Vy;
lastd_array[(Vx) + 102][(Vy) + 102] = 4;
for (; st <= en; st++) {
int x(fx[st]), y(fy[st]);
for (int k = 0; k < 4; k++) {
int _x(x + walk[k][0]), _y(y + walk[k][1]);
if (_x < -101 || _y < -101 || _x > 101 || _y > 101 ||
~lastd_array[(_x) + 102][(_y) + 102] ||
((_x) < -100 || (_x) > 100 || (_y) < -100 || (_y) > 100
? false
: tree_array[(_x) + 102][(_y) + 102]))
continue;
lastd_array[(_x) + 102][(_y) + 102] = k;
en++, fx[en] = _x, fy[en] = _y;
}
}
}
inline void Move(int k, int n) {
while (n-- > 0) {
ans.push_back(dir[k]);
if (!((Sx + walk[k][0]) < -100 || (Sx + walk[k][0]) > 100 ||
(Sy + walk[k][1]) < -100 || (Sy + walk[k][1]) > 100
? false
: tree_array[(Sx + walk[k][0]) + 102][(Sy + walk[k][1]) + 102]))
Sx += walk[k][0], Sy += walk[k][1];
Vx += walk[k][0], Vy += walk[k][1];
}
}
int main() {
scanf("%d%d%d%d%d", &Vx, &Vy, &Sx, &Sy, &M);
if (!M) return puts("-1"), 0;
int Ux, Uy(-101), Rx(-101), Ry, Dx, Dy(101), Lx(101), Ly;
for (int i = 1; i <= M; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x < Lx) Lx = x, Ly = y;
if (x > Rx) Rx = x, Ry = y;
if (y < Dy) Dx = x, Dy = y;
if (y > Uy) Ux = x, Uy = y;
tree_array[x + 102][y + 102] = true;
}
memset(lastd_array, 255, sizeof lastd_array);
Bfs();
if (!~lastd_array[(Sx) + 102][(Sy) + 102]) return puts("-1"), 0;
for (int x = Sx, y = Sy; x != Vx || y != Vy;) {
int k(lastd_array[(x) + 102][(y) + 102]);
dlist.push_front(k);
x -= walk[k][0], y -= walk[k][1];
}
while ((Vx != Sx || Vy != Sy) &&
(Vx >= Lx && Vx <= Rx && Vy >= Dy && Vy <= Uy ||
Sx >= Lx && Sx <= Rx && Sy >= Dy && Sy <= Uy)) {
int k(dlist.front());
ans.push_back(dir[k]);
dlist.pop_front();
if (!((Sx + walk[k][0]) < -100 || (Sx + walk[k][0]) > 100 ||
(Sy + walk[k][1]) < -100 || (Sy + walk[k][1]) > 100
? false
: tree_array[(Sx + walk[k][0]) + 102][(Sy + walk[k][1]) + 102])) {
dlist.push_back(k);
Sx += walk[k][0], Sy += walk[k][1];
}
Vx += walk[k][0], Vy += walk[k][1];
}
if (Vx < Sx) {
if (Sx > Rx) Move(2, Rx - Vx + 1), Move(1, Uy + 1 - min(Vy, Sy));
Move(0, Sx - Lx + 1);
if (Sy > Ly)
Move(3, Sy - Ly);
else
Move(1, Ly - Sy);
Move(2, Lx - Vx - 1);
}
if (Vx > Sx) {
if (Sx < Lx) Move(0, Vx - Lx + 1), Move(1, Uy + 1 - min(Vy, Sy));
Move(2, Rx - Sx + 1);
if (Sy > Ry)
Move(3, Sy - Ry);
else
Move(1, Ry - Sy);
Move(0, Vx - Rx - 1);
}
if (Vy < Sy) {
if (Sy > Uy) Move(1, Ux - Vx + 1), Move(2, Rx + 1 - min(Vx, Sx));
Move(3, Sy - Dy + 1);
if (Sx > Dx)
Move(0, Sx - Dx);
else
Move(2, Dx - Sx);
Move(1, Dy - Vy - 1);
}
if (Vy > Sy) {
if (Sy < Dy) Move(3, Vx - Dx + 1), Move(2, Rx + 1 - min(Vx, Sx));
Move(1, Uy - Sy + 1);
if (Sx > Ux)
Move(0, Sx - Ux);
else
Move(2, Ux - Sx);
Move(3, Vy - Uy - 1);
}
for (list<char>::iterator i = ans.begin(); i != ans.end(); i++) putchar(*i);
putchar('\n');
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string a, b;
cin >> a >> b;
if (a == b)
cout << a;
else {
cout << 1;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int a, b, p, x[10], res;
bool flag;
int main() {
scanf("%d%d%d", &a, &b, &p);
for (long long i = 1; i <= p && i <= a; i++) {
long long tmp = i * 1000000000LL;
tmp %= p;
if (p - tmp > b && tmp) {
flag = 1;
res = i;
break;
}
}
if (!flag)
printf("2\n");
else {
printf("1 ");
for (int i = 1; i <= 9; i++) x[i] = res % 10, res /= 10;
for (int i = 9; i; i--) printf("%d", x[i]);
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 998244353;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
long long n, m, L, R;
long long qpow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
long long inv(long long x) { return qpow(x, mod - 2); }
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> L >> R;
if (n * m % 2) {
cout << qpow(R - L + 1, n * m) << endl;
return 0;
}
long long wa = R / 2 - (L - 1) / 2;
long long wb = (R + 1) / 2 - L / 2;
if (wa == wb) {
long long val = qpow(R - L + 1, n * m);
cout << val * inv(2) % mod << endl;
}
if (wa == wb - 1) {
long long val = qpow(R - L + 1, n * m);
cout << ((val - 1) * inv(2) % mod + 1ll + mod) % mod << endl;
}
if (wa == wb + 1) {
long long val = qpow(R - L + 1, n * m);
cout << ((val - 1) * inv(2) % mod + 1ll + mod) % mod << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double INF = 1e9 + 22;
int n;
double l = -INF, r = INF;
pair<double, double> go(double r, double v, double r1, double r2) {
if (v == 0) {
if (r <= r1 || r >= r2) {
cout << -1;
exit(0);
}
return {-INF, INF};
}
if (v < 0) return go(-r, -v, -r2, -r1);
double e1, e2;
if (r > r1)
e1 = -INF;
else
e1 = (r1 - r) / v;
if (r >= r2) {
cout << -1;
exit(0);
}
e2 = (r2 - r) / v;
return {e1, e2};
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
double x1, Ehsan22, x2, y2;
cin >> n;
cin >> x1 >> Ehsan22 >> x2 >> y2;
for (int i = 1; i <= n; i++) {
double x, y, vx, vy;
pair<double, double> p1, p2;
cin >> x >> y >> vx >> vy;
p1 = go(x, vx, x1, x2);
p2 = go(y, vy, Ehsan22, y2);
l = max(l, max((p1.first), (p2.first)));
r = min(r, min((p1.second), (p2.second)));
}
if (l >= r || r < 0) return cout << -1, 0;
if (l < 0)
cout << 0;
else
cout << fixed << setprecision(6) << l;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long d[100500][2], dr[100500][2];
int a[100500];
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int br = a[i - 1];
d[i][0] = br - !(br & 1) + max(d[i - 1][0], d[i - 1][1]);
if (br > 1) d[i][1] = br - (br & 1) + d[i - 1][1];
}
for (int i = n - 2; i >= 0; i--) {
int br = a[i];
dr[i][0] = br - !(br & 1) + max(dr[i + 1][0], dr[i + 1][1]);
if (br > 1) dr[i][1] = br - (br & 1) + dr[i + 1][1];
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, d[i][1] + dr[i][1]);
ans = max(ans, d[i][0] + dr[i][1]);
ans = max(ans, d[i][1] + dr[i][0]);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void compute() {
int x1, y1, x2, y2, n;
cin >> x1 >> y1 >> x2 >> y2 >> n;
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
set<pair<int, int> > st;
for (int i = 0; i < n; i++) {
int x, y, r;
cin >> x >> y >> r;
for (int i = x1; i <= x2; i++) {
int flag = 0;
for (int j = y1; j <= y2; j++) {
if (((i - x) * (i - x) + (j - y) * (j - y)) <= r * r)
st.insert(make_pair(i, j));
if (i > x1 && i < x2 && !flag) {
j = y2 - 1, flag = 1;
continue;
}
if (flag) break;
}
}
}
cout << (long long int)2 * (abs(x2 - x1) + abs(y2 - y1)) - st.size() << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
compute();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long sum, min, max;
node(long long val = 0) : sum(val), min(val), max(val) {}
node(const node &x) : sum(x.sum), min(x.min), max(x.max) {}
node(const node &x, const node &y) {
sum = x.sum + y.sum;
min = ::min(x.min, x.sum + y.min);
max = ::max(x.max, x.sum + y.max);
}
};
template <typename T>
struct segtree {
vector<T> t;
segtree(int n) : t(n * 2) {}
void update(int i, const T &val) {
for (t[i += t.size() / 2] = val; i /= 2;) t[i] = T(t[i * 2], t[i * 2 + 1]);
}
T query(int l, int r, const T &def = T()) {
T a = def, b = def;
for (int i = l + t.size() / 2, j = r + t.size() / 2; i < j;
i /= 2, j /= 2) {
if (i % 2) a = T(a, t[i++]);
if (j % 2) b = T(b, t[--j]);
}
return T(a, b);
}
};
int main(int argc, char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
segtree<node> t(n);
int ans = 0;
for (int i = 0, pos = 0; i < s.size(); i++) {
if (s[i] == 'L') {
if (pos > 0) pos--;
} else if (s[i] == 'R') {
pos++;
} else if (s[i] == '(') {
t.update(pos, node(1));
} else if (s[i] == ')') {
t.update(pos, node(-1));
} else
t.update(pos, node(0));
node r = t.query(0, n - 1);
if (r.sum == 0 && r.min == 0)
cout << r.max << ' ';
else
cout << -1 << ' ';
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int sold[200005];
int m, n, k, t;
pair<int, pair<int, int> > traps[200005];
bool pass(int indurance) {
vector<pair<int, int> > leftTraps;
int i = 0;
while (indurance >= traps[i].first) i++;
int j = i;
while (j < k) leftTraps.push_back(traps[j++].second);
sort(leftTraps.begin(), leftTraps.end());
int l = leftTraps.size();
int total_time = 0;
int last = -1;
i = 0;
while (i < l) {
j = i + 1;
int firstPos = leftTraps[i].first;
int maxWantedPos = leftTraps[i].second;
while (leftTraps[j].first <= maxWantedPos && j < l) {
maxWantedPos = max(maxWantedPos, leftTraps[j].second);
j++;
}
total_time += 2 * (maxWantedPos - firstPos + 1);
i = j;
}
return (n + 1 + total_time <= t);
}
int BS() {
int e = m - 1, s = 0, mid;
while (e > s + 1) {
mid = (e + s) / 2;
if (pass(sold[mid]))
e = mid;
else
s = mid + 1;
}
while (pass(sold[e - 1]) && e >= 1) e--;
if (!pass(sold[e])) return m;
return e;
}
int main() {
cin >> m >> n >> k >> t;
for (int i = 0; i < m; i++) cin >> sold[i];
sort(sold, sold + m);
for (int i = 0; i < k; i++) {
int l, r, d;
cin >> l >> r >> d;
pair<int, int> z = make_pair(l, r);
traps[i] = make_pair(d, z);
}
sort(traps, traps + k);
int x = BS();
cout << m - x << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N;
int a[2000005];
int main() {
int i, j, k, next, s;
cin >> N;
for (i = 1; i <= N; ++i) a[i] = i;
for (i = 2; i <= N; ++i)
for (j = i - 1, s = a[j]; j < N + i - 1; j += i) {
if (j + i < N + i - 1) {
next = a[j + i];
a[j + i] = s;
s = next;
} else {
a[N + i - 1] = s;
}
}
for (i = N; i <= 2 * N - 1; ++i) printf("%d ", a[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 9;
const long long MAX_SIZE = 1e7 + 1;
long long _t = 1, _T, csn;
long long max(long long a, long long b) {
if (a < b) return b;
return a;
}
long long min(long long a, long long b) {
if (a > b) return b;
return a;
}
long long mmi(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long nxor(long long n) {
if (n % 4 == 0) return n;
if (n % 4 == 1) return 1;
if (n % 4 == 2) return n + 1;
return 0;
}
long long sum(long long n) { return ((n * (n + 1)) / 2); }
long long modsum(long long n, long long m) {
long long ans = n % m;
ans *= (n + 1) % m;
ans %= m;
ans *= mmi(2, m);
return ans % m;
}
long long leap(long long y) {
if (y % 400 == 0)
return 1;
else if (y % 100 == 0)
return 0;
else if (y % 4 == 0)
return 1;
else
return 0;
}
long long mypow(long long x, long long n) {
long long nn = n, ans = 1;
while (nn) {
if (nn % 2)
ans *= x, nn--;
else
x *= x, nn /= 2;
}
return ans;
}
long long modpow(long long x, long long n, long long md) {
long long nn = n, ans = 1;
while (nn) {
if (nn % 2)
ans *= x, ans %= md, nn--;
else
x *= x, x %= md, nn /= 2;
}
return ans;
}
void solve();
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
bool multicases = 1;
if (multicases) cin >> _t;
_T = _t;
while (_t--) solve();
return 0;
}
void solve() {
csn = _T - _t;
long long n;
cin >> n;
;
vector<long long> neg, pos;
for (long long i = 0; i < n; i += 1) {
long long x;
cin >> x;
;
if (x >= 0)
pos.emplace_back(x);
else
neg.emplace_back(x);
}
long long ans = -1e18;
sort(pos.begin(), pos.end());
sort(neg.begin(), neg.end());
reverse(pos.begin(), pos.end());
long long temp = 1, nn = neg.size(), pp = pos.size();
for (long long i = 0; i < 6; i += 1) {
temp = 1;
if (pp >= 5 - i && nn >= i) {
for (long long j = 0; j < 5 - i; j += 1) temp *= pos[j];
for (long long j = 0; j < i; j += 1) temp *= neg[j];
ans = max(ans, temp);
}
reverse(neg.begin(), neg.end());
}
cout << ans << "\n";
return;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000;
int N;
long long arr[MAXN];
long long res[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin >> N;
bool seen = false;
for (int i = 0; i < N; i++) {
cin >> arr[i];
if (arr[i] != arr[0]) seen = true;
arr[i + N] = arr[i];
}
if (!seen) {
if (arr[0] == 0) {
cout << "YES\n";
for (int i = 0; i < N; i++) {
if (i) cout << " ";
cout << "1";
}
cout << "\n";
} else {
cout << "NO\n";
}
return 0;
}
long long cm = 0;
for (int i = 0; i < N; i++) cm = max(cm, arr[i]);
for (int i = N; i < 2 * N; i++) {
if (arr[i] == cm && arr[i - 1] != cm) {
res[i % N] = cm;
long long ctot = cm;
for (int j = i - 1; j > i - N; j--) {
if (j == i - 1) ctot = 2 * ctot;
ctot += arr[j];
res[j % N] = ctot;
}
break;
}
}
cout << "YES\n";
for (int i = 0; i < N; i++) cout << res[i] << " ";
cout << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const int N = 1e5 + 5, P = 500;
double p[N], sum[N];
vector<int> g[N], w[N];
bool vip[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
double ans = 0;
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i] = 1 - p[i];
ans += p[i];
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
ans -= p[a] * p[b];
}
for (int i = 0; i < n; i++) {
if (g[i].size() > P) {
vip[i] = 1;
for (int to : g[i]) w[to].push_back(i);
}
}
for (int i = 0; i < n; i++) {
for (int to : g[i]) {
if (!vip[to]) sum[i] += p[to];
}
}
int q;
cin >> q;
cout << fixed << setprecision(10);
while (q--) {
int x;
double y;
cin >> x >> y;
y = 1 - y;
ans += y - p[x];
double s = sum[x];
for (int to : w[x]) {
s += p[to];
}
if (!vip[x]) {
for (int to : g[x]) {
sum[to] += y - p[x];
}
}
ans = ans - s * y + p[x] * s;
p[x] = y;
cout << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char action[32];
int team[32];
int m;
int dp[20][1 << 20];
int s[128];
int dpf(int turn, int mask) {
if (turn == m) return 0;
int &r = dp[turn][mask];
if (r != -1) return r;
r = team[turn] == 1 ? -1000000007 : 1000000007;
if (action[turn] == 'p') {
for (int i = 0; i < m; i++)
if (!(mask & (1 << i)))
if (team[turn] == 1)
r = max(r, s[i] + dpf(turn + 1, mask | (1 << i)));
else
r = min(r, -s[i] + dpf(turn + 1, mask | (1 << i)));
} else {
for (int i = 0; i < m; i++)
if (!(mask & (1 << i)))
if (team[turn] == 1)
r = max(r, dpf(turn + 1, mask | (1 << i)));
else
r = min(r, dpf(turn + 1, mask | (1 << i)));
}
return r;
}
int main() {
std::ios::sync_with_stdio(false);
int n = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
sort(s, s + n);
reverse(s, s + n);
cin >> m;
for (int i = 0; i < m; i++) cin >> action[i] >> team[i];
memset(dp, 0xFF, sizeof dp);
cout << dpf(0, 0) << endl;
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
#define inf 1e6
const int maxN = 200000, maxK = 17;
const int maxBitMask = 131072;
int n,k;
string cad;
int link[maxK][maxN]; // indica cual es la primer posicion + 1 a partir de i en la que se acaba de sobrepasar el numero de caracteres requeridos consecutivos
int acu[maxK][maxN]; // indica cuantos caracteres consecutivos finales son '?' o el i-esimo caracter
int dp[maxBitMask];
void preprocesar(){
for(int i=0; i<k; i++){
acu[i][0] = 0;
if((cad[0] == '?') || (cad[0] == (char)('a' + i)))
acu[i][0] = 1;
for(int j=1; j<n; j++){
if((cad[j] == '?') || (cad[j] == (char)('a' + i)))
acu[i][j] = acu[i][j-1] + 1;
else
acu[i][j] = 0;
}
}
}
void preprocesarLink(int length){
for(int i=0; i<k; i++){
for(int j=0; j<n; j++)
link[i][j] = -1;
}
for(int i=0; i<k; i++){
int last = 0;
for(int j=0; j<n; j++){
if(acu[i][j] >= length){
for(; last<=j+1-length; last++)
link[i][last] = j+1;
}
}
}
}
int validar(int length){
if(length == 0) return 1;
preprocesarLink(length);
int lim = 1<<(k);
dp[0] = 0;
for(int i=1; i<lim; i++){
dp[i] = inf;
for(int j=0,p=1; p<=i; j++, p<<=1){
if((((i-p) | p) == i) && (dp[i-p] < n) && (link[j][dp[i-p]] != -1))
dp[i] = min(dp[i], link[j][dp[i-p]]);
}
}
if(dp[lim-1] != inf)
return 1;
return 0;
}
int solver(){
int first = 0, last = n;
while(first < last){
int m = (first + last + 1) / 2;
if(validar(m) == 1) first = m;
else last = m-1;
}
return first;
}
int main(){
ios_base::sync_with_stdio(0);cin.tie(NULL);
cin>>n>>k>>cad;
preprocesar();
int ans = solver();
cout<<ans<<endl;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, d, max = -2, sum, sum1, ans, c, z, x;
cin >> n;
int a[n];
map<long long, int> m;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
sum = 0;
for (z = i; z <= j; z++) sum += a[z];
sum1 = 0;
x = 0;
c = 0;
m.clear();
m[0] = 0;
for (z = 0; z < i; z++) {
sum1 += a[z];
if (m.find(sum1 - sum) != m.end()) {
c++;
sum1 = 0;
m.clear();
}
m[sum1] = z;
}
sum1 = 0;
m.clear();
for (z = j + 1; z < n; z++) {
sum1 += a[z];
if (m.find(sum1 - sum) != m.end()) {
c++;
sum1 = 0;
m.clear();
}
m[sum1] = z;
}
if (c > max) {
max = c;
ans = sum;
}
}
}
cout << max + 1 << "\n";
sum = ans;
sum1 = 0;
m.clear();
m[0] = -1;
for (z = 0; z < n; z++) {
sum1 += a[z];
if (m.find(sum1 - sum) != m.end()) {
c++;
cout << m[sum1 - sum] + 2 << " " << z + 1 << "\n";
m.clear();
sum1 = 0;
}
m[sum1] = z;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long get(long long n) {
for (long long i = 2; i * i <= n; ++i)
if (n % i == 0) return i;
return n;
}
int main() {
long long n;
cin >> n;
long long cnt = 0;
if (n % 2 != 0) {
n -= get(n);
++cnt;
}
cout << cnt + n / 2;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct S {
int a, b;
S() {}
S(int _a, int _b) {
a = _a;
b = _b;
}
const bool operator<(const S &o) const { return a < o.a; }
};
priority_queue<int, vector<int>, greater<int>> mpq;
const int SPACE = 0, NL = 1;
string exm;
inline void showAll(vector<int> &v, int sep) {
for (int &here : v) printf("%d%c", here, (sep) ? '\n' : ' ');
}
inline void exf(void) {
cout << exm << "\n";
exit(0);
}
inline vector<int> int_seperation(int N, int d = 10) {
vector<int> v;
while (N) {
v.push_back(N % d);
N /= d;
}
reverse(v.begin(), v.end());
return v;
}
const int SIZE = 200009;
int arr[SIZE];
int last = 0, n, l, r;
vector<int> ans;
void r_oper() {
last = arr[r];
r--;
ans.push_back(1);
}
void l_oper() {
last = arr[l];
l++;
ans.push_back(-1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
l = 1, r = n;
for (int i = 1; i <= n; i++) {
if (arr[l] > last && arr[r] > last) {
if (arr[l] == arr[r]) {
int l_cnt = 0, r_cnt = 0;
for (int j = l + 1; j <= n; j++) {
if (arr[j] > arr[j - 1])
l_cnt++;
else
break;
}
for (int j = r - 1; j >= 1; j--) {
if (arr[j] > arr[j + 1])
r_cnt++;
else
break;
}
if (l_cnt > r_cnt) {
for (int j = 0; j < l_cnt + 1; j++) {
l_oper();
}
break;
} else {
for (int j = 0; j < r_cnt + 1; j++) {
r_oper();
}
break;
}
}
if (arr[l] > arr[r]) {
r_oper();
} else
l_oper();
}
if (arr[l] > last && arr[r] <= last)
l_oper();
else if (arr[r] > last && arr[l] <= last)
r_oper();
}
printf("%d\n", ans.size());
for (int here : ans) {
if (here == 1)
printf("R");
else
printf("L");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, a1, b1, c1;
cin >> a >> b >> c >> a1 >> b1 >> c1;
int f = 0, g = 0;
if (a > a1 + 1)
f += (a - a1) / 2;
else if (a < a1)
g += a1 - a;
if (b > b1 + 1)
f += (b - b1) / 2;
else if (b < b1)
g += b1 - b;
if (c > c1 + 1)
f += (c - c1) / 2;
else if (c < c1)
g += c1 - c;
if (f >= g)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, dp[105], ans, c;
vector<long long> a[105];
void dfs(long long i, long long k) {
if (dp[i] != -1) {
c += (dp[i] != k);
return;
}
dp[i] = k;
for (auto j : a[i]) dfs(j, k ^ 1);
}
void solve() {
cin >> n >> m;
for (__typeof((n + 1)) i = (1); i < (n + 1); i++) dp[i] = -1;
while (m--) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (__typeof((n + 1)) i = (1); i < (n + 1); i++) {
if (dp[i] == -1) {
c = 0;
dfs(i, 0);
ans += c / 2;
}
}
ans += (n - ans) % 2;
{
cout << ans << "\n";
return;
};
}
void prep() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
prep();
cout << fixed << setprecision(12);
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const string TASK = "";
const int maxn = 2e3 + 1;
long long n, k, p, a[maxn], b[maxn], d[maxn][maxn];
bool f[maxn], fl;
void Enter() {
cin >> n >> k >> p;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= k; ++i) cin >> b[i];
}
void Init() {
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= k; ++j) {
d[i][j] = abs(a[i] - b[j]) + abs(b[j] - p);
}
}
bool Check(long long h) {
fill(f + 1, f + k + 1, 0);
for (int i = 1; i <= n; ++i) {
fl = 0;
for (int j = 1; j <= k; ++j)
if (!f[j] && d[i][j] <= h) {
f[j] = 1;
fl = 1;
break;
}
if (!fl) return 0;
}
}
void Solve() {
long long l = 0;
long long r = 2e9;
while (l <= r) {
long long m = (l + r) / 2;
if (!Check(m))
l = m + 1;
else
r = m - 1;
}
cout << l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Enter();
Init();
Solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> F;
for (int i = 0; i < n; i++) {
int ele;
cin >> ele;
F.push_back(ele);
}
vector<int> G = vector<int>(n, -1);
vector<int> H;
int cur = 1;
unordered_set<int> used;
for (int i = 0; i < n; i++) {
if (F[i] != F[F[i] - 1]) {
cout << -1 << endl;
return 0;
}
if (G[i] != -1 || G[F[i] - 1] != -1) {
G[i] = max(G[i], G[F[i] - 1]);
G[F[i] - 1] = G[i];
} else {
G[i] = cur;
G[F[i] - 1] = cur;
cur++;
}
if (used.find(F[i]) == used.end()) {
H.push_back(F[i]);
used.insert(F[i]);
}
}
cout << H.size() << endl;
for (auto g : G) {
cout << g << " ";
}
cout << endl;
for (auto h : H) {
cout << h << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T& n) {
T w = 1;
n = 0;
char ch = getchar();
while (!isdigit(ch) && ch != EOF) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch) && ch != EOF) {
n = (n << 1) + (n << 3) + (ch ^ 48);
ch = getchar();
}
n *= w;
}
const long long HASHMAX = 3;
const int MAXN = 200005;
int numbers[MAXN];
long long hash[15][15][10];
long long tag_hash[15];
long long hash_tmp[15];
int select_index[15];
std::vector<long long> primes(HASHMAX);
long long MOD_MAX = 9999999999997;
int main(int argc, char* argv[]) {
srand(time(0));
for (auto i = 0; i < HASHMAX; i++) {
primes[i] = rand() % 9999997;
}
int t;
long long n, m, k, z;
read(n);
read(m);
read(k);
std::vector<std::vector<std::pair<long long, long long>>> out_edges(n + 5);
long long u, v, w;
for (auto i = 0; i < m; i++) {
read(u);
read(v);
read(w);
out_edges[u].emplace_back(w, v);
}
for (auto i = 1; i <= n; i++) {
sort(out_edges[i].begin(), out_edges[i].end());
int degree = int(out_edges[i].size());
for (long long j = 0; j < degree; j++) {
for (long long ii = 0; ii < HASHMAX; ii++) {
long long val = out_edges[i][j].second;
hash[degree][j + 1][ii] += (val * (primes[ii] + val) +
(val * val * (val + primes[ii])) % MOD_MAX);
}
}
}
for (long long j = 0; j < HASHMAX; j++)
for (long long i = 1; i <= n; i++) {
{
tag_hash[j] +=
(i * (primes[j] + i) + (i * i * (primes[j] + i)) % MOD_MAX);
}
}
long long cnt_res = 0;
for (auto i = 1; i <= k; i++) {
select_index[i] = 1;
}
while (!select_index[k + 1]) {
bool ok_tag = true;
for (auto i = 0; i < HASHMAX; i++) {
hash_tmp[i] = 0;
}
for (auto i = 1; i <= k; i++) {
for (auto j = 0; j < HASHMAX; j++) {
hash_tmp[j] += hash[i][select_index[i]][j];
}
}
for (auto i = 0; i < HASHMAX; i++) {
if (hash_tmp[i] != tag_hash[i]) {
ok_tag = false;
break;
}
}
if (ok_tag) {
cnt_res++;
}
select_index[1]++;
int index_now = 1;
while (select_index[index_now] > index_now) {
select_index[index_now] = 1;
select_index[index_now + 1]++;
index_now++;
}
}
printf("%lld\n", cnt_res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
vector<int> my(200005), B(200005);
int book[200005], p[200005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> my[i];
book[my[i]]++;
}
for (int i = 1; i <= n; ++i) {
cin >> B[i];
p[B[i]] = i;
}
if (p[1]) {
int flag = 1;
int th = p[1];
for (int i = th + 1; i <= n; ++i) {
if (B[i] != B[i - 1] + 1) {
flag = 0;
break;
}
}
if (flag) {
int now = B[n], ans = 0;
for (int i = now + 1; i <= n; ++i) {
if (book[i]) {
ans++;
book[i] = 0;
book[B[i - now]]++;
} else {
flag = 0;
break;
}
}
if (flag) {
cout << ans << endl;
return 0;
}
}
}
int ans = n;
for (int i = 1; i <= n; ++i)
if (p[i]) ans = max(ans, p[i] - i + 1 + n);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 123;
const int INF = (int)1e9 + 123;
const double eps = 1e-6;
int a, b, c, d;
void check_possibility() {
if (abs(c - d) > 1 || a < c || b < d) {
cout << -1;
exit(0);
}
}
void check() {
if (a < 0 || b < 0) {
cout << -1;
exit(0);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> a >> b >> c >> d;
check_possibility();
if (c > d) {
a -= c;
b -= c;
check();
for (int i = 1; i <= a; i++) {
cout << 4;
}
for (int i = 1; i <= c; i++) {
cout << 47;
}
for (int i = 1; i <= b; i++) {
cout << 7;
}
return 0;
}
if (c == d) {
a -= c + 1;
b -= c;
if (a == -1) {
a++;
b--;
check();
cout << 74;
--d;
for (int i = 1; i <= a; i++) {
cout << 4;
}
for (int i = 1; i < d; i++) {
cout << 74;
}
if (d) cout << 74;
cout << 7;
for (int i = 1; i <= b; i++) {
cout << 7;
}
return 0;
}
check();
for (int i = 1; i <= a; i++) {
cout << 4;
}
for (int i = 1; i <= c; i++) {
cout << 47;
}
for (int i = 1; i <= b; i++) {
cout << 7;
}
cout << 4;
return 0;
} else {
a -= d;
b -= d;
check();
cout << 74;
--d;
for (int i = 1; i <= a; i++) {
cout << 4;
}
for (int i = 1; i < d; i++) {
cout << 74;
}
for (int i = 1; i <= b; i++) {
cout << 7;
}
if (d)
;
cout << 74;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
struct Node {
char str[100];
int val;
int index;
} node[maxn * 2];
int ha[maxn][2];
int pai[maxn];
int cmp(Node a, Node b) { return strcmp(a.str, b.str) < 0; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", &node[i * 2].str);
scanf("%s", &node[i * 2 + 1].str);
node[i * 2].index = i + 1;
node[i * 2 + 1].index = i + 1;
}
for (int i = 1; i <= n; i++) scanf("%d", &pai[i]);
sort(node, node + 2 * n, cmp);
memset(ha, 0, sizeof(ha));
int cnt = 1;
for (int i = 0; i < 2 * n; i++) {
node[i].val = cnt++;
int index = node[i].index;
if (!ha[index][0])
ha[index][0] = node[i].val;
else {
if (node[i].val < ha[index][0]) {
int tmp = ha[index][0];
ha[index][0] = node[i].val;
ha[index][1] = tmp;
} else {
ha[index][1] = node[i].val;
}
}
}
int point_a = 0;
int flag = 0;
for (int i = 1; i <= n; i++) {
int index = pai[i];
if (ha[index][1] < point_a) {
flag = 1;
break;
}
if (ha[index][0] > point_a)
point_a = ha[index][0];
else if (ha[index][1] > point_a)
point_a = ha[index][1];
}
if (!flag)
puts("YES");
else
puts("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool b[2000005];
char c[2000005];
int h[2000005], q[2000005];
int i, j, k, n, H, T, t;
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (i = 1; i <= n; i++) t += (c[i] == '(') ? 1 : -1;
for (i = n + 1; i <= n * 2; i++) c[i] = c[i - n];
if (t < 0)
for (i = 1; i <= -t; i++) putchar('(');
for (i = 1; i <= 2 * n; i++) h[i] = h[i - 1] + ((c[i] == '(') ? 1 : -1);
H = 1;
T = 0;
for (i = 1; i <= n; i++) {
for (; T && h[i] < h[q[T]]; T--)
;
q[++T] = i;
}
for (i = 1; i <= n; i++) {
if (h[q[H]] - h[i - 1] < min(t, 0)) b[i] = 1;
for (; T >= H && h[n + i] < h[q[T]]; T--)
;
q[++T] = n + i;
if (q[H] == i) H++;
}
for (i = 1, j = 2;;) {
for (; b[i]; i++)
;
for (; b[j]; j++)
;
if (i == j)
for (j++; b[j]; j++)
;
if (i > n || j > n) break;
for (k = 0; k < n && c[i + k] == c[j + k]; k++)
;
if (c[i + k] < c[j + k])
j = j + k + 1;
else
i = i + k + 1;
}
if (j < i) i = j;
for (j = i; j < n + i; j++) putchar(c[j]);
if (t > 0)
for (i = 1; i <= t; i++) putchar(')');
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int64_t sum1 = 0;
int64_t sum2 = 0;
int cnt = 0;
int zero = 0;
std::set<std::pair<int, int>> st;
std::set<std::pair<int, int>> st2;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (y > 0) {
if (x == 1) cnt++;
sum1 += y;
st2.insert({y, x});
} else {
y = -y;
sum1 -= y;
auto it = st2.find({y, x});
if (it != st2.end()) {
st2.erase(it);
} else {
it = st.find({y, x});
st.erase(it);
if (x == 0) zero--;
sum2 -= y;
}
if (x == 1) {
cnt--;
if (st.size() > 0) {
auto it = st.begin();
std::pair<int, int> now = *it;
if (now.second == 0) zero--;
st.erase(it);
sum2 -= now.first;
st2.insert(now);
}
}
}
if (st.size() != cnt && st2.size() > 0) {
auto it = --st2.end();
std::pair<int, int> now = *it;
st.insert(now);
if (now.second == 0) zero++;
sum2 += now.first;
st2.erase(it);
}
if (st.size() > 0 && st2.size() > 0) {
auto it = st.begin();
auto it2 = --st2.end();
st.erase(it);
st2.erase(it2);
std::pair<int, int> now1 = *it;
std::pair<int, int> now2 = *it2;
if (now2.first > now1.first) {
sum2 += now2.first - now1.first;
if (now2.second == 0) zero++;
if (now1.second == 0) zero--;
st.insert(now2);
st2.insert(now1);
} else {
st.insert(now1);
st2.insert(now2);
}
}
if (st.size() > 0 && zero == 0 && st.size() == cnt) {
auto it1 = st.begin();
std::pair<int, int> now = *it1;
st.erase(it1);
sum2 -= now.first;
if (st2.size() > 0) {
auto it2 = --st2.end();
std::pair<int, int> now2 = *it2;
st2.erase(it2);
st.insert(now2);
zero++;
sum2 += now2.first;
}
st2.insert(now);
}
printf("%lld\n", sum1 + sum2);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N;
int v[200005];
int add[200005];
int res[200005];
int ori[200005];
vector<int> path[200005];
vector<int> weight[200005];
long long currsum[200005];
void dfs(int pos, long long sum, int d) {
ori[d] = pos;
currsum[d] = sum;
int lo = 0;
int hi = d;
int mid;
long long cari = sum - v[pos];
while (lo < hi) {
mid = (lo + hi) / 2;
if (currsum[mid] >= cari) {
hi = mid;
} else
lo = mid + 1;
}
add[ori[hi]]++;
int M = path[pos].size();
for (int i = 0; i < M; i++) {
dfs(path[pos][i], sum + weight[pos][i], d + 1);
}
}
pair<int, int> dfs2(int pos) {
pair<int, int> sumz;
int M = path[pos].size();
for (int i = 0; i < M; i++) {
pair<int, int> lho = dfs2(path[pos][i]);
sumz.first += lho.first;
sumz.second += lho.second;
}
res[pos] = sumz.first - sumz.second;
sumz.first++;
sumz.second += add[pos];
return sumz;
}
int main() {
scanf("%d", &N);
;
for (int i = 0; i < N; i++) scanf("%d", &v[i]);
;
for (int i = 1; i < N; i++) {
int a, b;
scanf("%d", &a);
;
scanf("%d", &b);
;
a--;
path[a].push_back(i);
weight[a].push_back(b);
}
dfs(0, 0, 0);
dfs2(0);
for (int i = 0; i < N; i++) cout << res[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
const int inf = (int)1e9;
const int mod = 1e9 + 7;
using namespace std;
int a[111], ans = 0;
bool cmp(int x, int y) { return (x > y); }
bool u[111];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
if (u[i]) continue;
u[i] = 1;
ans++;
int cnt = 1;
for (int j = i + 1; j <= n; j++) {
if (!u[j] && a[j] >= cnt) {
u[j] = 1;
cnt++;
}
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 200100;
int n;
int L[N], R[N], U[N], D[N];
namespace hsh_map {
int tot[2], X[N], Y[N];
int binary_search(int *a, int x, int opt) {
int l(1), r(tot[opt]), mid;
while (l <= r) {
mid = (l + r) >> 1;
a[mid] <= x ? l = mid + 1 : r = mid - 1;
}
return l - 1;
}
void Main() {
register int i;
for (i = 1; i <= n; ++i)
X[++tot[0]] = L[i], Y[tot[0]] = D[i], X[++tot[0]] = R[i], Y[tot[0]] = U[i];
sort(X + 1, X + 1 + tot[0]), sort(Y + 1, Y + 1 + tot[0]);
tot[1] = unique(Y + 1, Y + 1 + tot[0]) - Y;
tot[0] = unique(X + 1, X + 1 + tot[0]) - X;
for (i = 1; i <= n; ++i)
L[i] = binary_search(X, L[i], 0), R[i] = binary_search(X, R[i], 0),
D[i] = binary_search(Y, D[i], 1), U[i] = binary_search(Y, U[i], 1);
}
} // namespace hsh_map
struct node {
set<int> st[2];
int top[2], cover, mx_remain, mn_cover;
node() { top[0] = top[1] = cover = mx_remain = mn_cover = -1; }
void erase(int x) { st[0].erase(x), st[1].erase(x); }
void insert(int x) { st[0].insert(x); }
void move(int x) { st[0].erase(x), st[1].insert(x); }
void update() {
top[0] = st[0].size() ? *st[0].rbegin() : -1;
top[1] = st[1].size() ? *st[1].rbegin() : -1;
cover = max(top[0], top[1]);
}
} v[N << 2];
inline void pushup(int o, int l, int r) {
if (l == r) {
v[o].mn_cover = v[o].top[1];
v[o].mx_remain = v[o].top[0] < v[o].mn_cover ? -1 : v[o].top[0];
return;
}
int ls = o << 1, rs = o << 1 | 1;
v[o].mn_cover = max(v[o].top[1], min(v[ls].mn_cover, v[rs].mn_cover));
v[o].mx_remain = max(v[o].top[0] < v[o].mn_cover ? -1 : v[o].top[0],
max(v[ls].mx_remain, v[rs].mx_remain) < v[o].top[1]
? -1
: max(v[ls].mx_remain, v[rs].mx_remain));
}
void insert(int k, int l, int r, int x, int y, int val) {
if (x <= l && y >= r) {
v[k].insert(val);
v[k].update();
pushup(k, l, r);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) insert(k << 1, l, mid, x, y, val);
if (y > mid) insert(k << 1 | 1, mid + 1, r, x, y, val);
pushup(k, l, r);
}
void del(int k, int l, int r, int x, int y, int val) {
if (x <= l && y >= r) {
v[k].erase(val);
v[k].update();
pushup(k, l, r);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) del(k << 1, l, mid, x, y, val);
if (y > mid) del(k << 1 | 1, mid + 1, r, x, y, val);
pushup(k, l, r);
}
void move(int k, int l, int r, int x, int y, int val) {
if (x <= l && y >= r) {
v[k].move(val);
v[k].update();
pushup(k, l, r);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) move(k << 1, l, mid, x, y, val);
if (y > mid) move(k << 1 | 1, mid + 1, r, x, y, val);
pushup(k, l, r);
}
struct rectangle {
int d, u, opt, pos;
};
vector<rectangle> rec[N];
int main() {
n = read();
register int i, j;
for (i = 1; i <= n; ++i)
L[i] = read(), D[i] = read(), R[i] = read(), U[i] = read();
hsh_map::Main();
for (i = 1; i <= n; ++i)
U[i]--, rec[L[i]].push_back((rectangle){D[i], U[i], 1, i}),
rec[R[i]].push_back((rectangle){D[i], U[i], 0, i});
int ans(1);
for (i = 1; i <= n + n; ++i) {
for (j = 0; j < rec[i].size(); ++j)
rec[i][j].opt
? insert(1, 1, n + n, rec[i][j].d, rec[i][j].u, rec[i][j].pos)
: del(1, 1, n + n, rec[i][j].d, rec[i][j].u, rec[i][j].pos);
while (v[1].mx_remain != -1)
ans++, move(1, 1, n + n, D[v[1].mx_remain], U[v[1].mx_remain],
v[1].mx_remain);
}
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC diagnostic ignored "-Wmissing-declarations"
inline int safe_mul(int x, int y) __attribute__((warn_unused_result));
int const maxn = 20;
double d[1 << maxn][maxn];
double a[maxn][maxn];
int n;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> a[i][j];
int l = 1 << n;
d[1][0] = 1.0;
for (int mask = 2; mask < l; ++mask) {
for (int i = 0; i < n; ++i)
if (mask & (1 << i)) {
for (int j = 0; j < n; ++j)
if (j != i && (1 << j) & mask) {
d[mask][i] = max(d[mask][i], d[mask ^ (1 << j)][i] * a[i][j] +
d[mask ^ (1 << i)][j] * a[j][i]);
}
}
}
double best = 0.0;
for (int i = 0; i < n; ++i) best = max(best, d[l - 1][i]);
cout << fixed << setprecision(10) << best << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[222222];
int b[222222];
map<pair<int, int>, int> mp;
int main() {
int n;
scanf("%i", &n);
int64_t ans = 0;
for (int i = 0; i < n; i++) {
scanf("%i", &a[i]);
ans += a[i];
}
int m;
scanf("%i", &m);
for (int i = 0; i < m; i++) {
int x, y, z;
scanf("%i%i%i", &x, &y, &z);
if (mp.count({x, y}) > 0) {
auto xx = mp.find({x, y});
if (b[xx->second - 1] <= a[xx->second - 1]) ans++;
b[xx->second - 1]--;
mp.erase(mp.find({x, y}));
}
if (z == 0) {
printf("%lld\n", ans);
continue;
}
mp[{x, y}] = z;
b[z - 1]++;
if (b[z - 1] <= a[z - 1]) ans--;
printf("%lld\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = 0, i, c = 0, flag = 0, len;
len = s.length();
while (l < len - 6) {
c = 0;
for (i = 0; i < 7; i++) {
if (s[i + l] == s[l])
c++;
else
c = 0;
if (c == 7) {
flag = 1;
break;
}
}
l++;
}
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 9, MOD = 1e9 + 7;
using vi = vector<long long>;
using vb = vector<bool>;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long q;
cin >> q;
for (long long j = 0; j < q; j++) {
long long n;
cin >> n;
vi a;
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
a.push_back(k);
}
sort(a.rbegin(), a.rend());
a.erase(unique(a.begin(), a.end()), a.end());
long long ans = a[0];
for (long long i = 0; i < a.size() - 1; i++) {
for (long long i1 = i + 1; i1 < a.size(); i1++) {
if (a[i] % a[i1]) {
ans = max(ans, a[i] + a[i1]);
break;
}
}
}
for (long long i = 0; i < a.size() - 2 && a[i] + a[i + 1] + a[i + 2] > ans;
i++) {
for (long long i1 = i + 1;
i1 < a.size() - 1 && a[i] + a[i1] + a[i1 + 1] > ans; i1++) {
if (a[i] % a[i1] == 0) continue;
for (long long i3 = i1 + 1; i3 < a.size() && a[i] + a[i1] + a[i3] > ans;
i3++) {
if (a[i] % a[i3] && a[i1] % a[i3]) {
ans = max(ans, a[i] + a[i1] + a[i3]);
break;
}
}
}
}
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double epsylon = 1e-9;
const std::string PROGRAM_NAME = "ivo";
int main() {
int n, p;
cin >> n >> p;
vector<pair<int, int> > a(n);
for (int i = 0; i < (int)a.size(); ++i) {
scanf("%d %d", &a[i].first, &a[i].second);
}
double res = 0;
for (int i = 0; i < (int)a.size(); ++i) {
int x = i;
int y = (i + 1) % n;
int goodx = a[x].second / p - (a[x].first - 1) / p;
int badx = (a[x].second - a[x].first + 1) - goodx;
int goody = a[y].second / p - (a[y].first - 1) / p;
int bady = (a[y].second - a[y].first + 1) - goody;
double px = double(badx) / double(a[x].second - a[x].first + 1);
double py = double(bady) / double(a[y].second - a[y].first + 1);
res += (1.0 - px * py) * 2000.0;
}
printf("%.9lf\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
if (n / k % 2)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x, y, s = 0;
cin >> n;
int a[n], b[n];
char v[n];
for (i = 0; i < n; i++) {
cin >> x;
a[i] = x;
cin >> y;
b[i] = y;
}
for (i = 0; i < n; i++) {
if (i == 0) {
if (a[0] <= b[0])
v[i] = 'A';
else
v[i] = 'G';
if (a[0] <= b[0])
s += a[0];
else
s -= b[0];
} else {
if (abs(s + a[i]) <= abs(s - b[i])) {
s += a[i];
v[i] = 'A';
} else {
s -= b[i];
v[i] = 'G';
}
}
}
if (abs(s) <= 500) {
for (i = 0; i < n; i++) cout << v[i];
cout << endl;
} else
cout << -1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s[2];
int dp[18][200000][2][2];
int solve(int a1, int b1, int a2, int b2) {
int ret = -2;
if (a1 != -1 && b1 != -1) {
if (ret == -2)
ret = a1 + b1;
else
ret = min(ret, a1 + b1);
}
if (a2 != -1 && b2 != -1) {
if (ret == -2)
ret = a2 + b2;
else
ret = min(ret, a2 + b2);
}
return ++ret;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> s[0] >> s[1];
for (int i = 0; i < n; ++i) {
dp[0][i][0][0] = (s[0][i] == '.' ? 0 : -1);
dp[0][i][0][1] = dp[0][i][1][0] =
((s[0][i] == '.' && s[1][i] == '.') ? 1 : -1);
dp[0][i][1][1] = (s[1][i] == '.' ? 0 : -1);
}
for (int i = 1; (1 << i) <= n; ++i) {
int sz = (1 << i);
int sz2 = (1 << (i - 1));
for (int j = 0; j + sz <= n; ++j)
for (int b1 = 0; b1 <= 1; ++b1)
for (int b2 = 0; b2 <= 1; ++b2)
dp[i][j][b1][b2] =
solve(dp[i - 1][j][b1][0], dp[i - 1][j + sz2][0][b2],
dp[i - 1][j][b1][1], dp[i - 1][j + sz2][1][b2]);
}
int x, y;
int aux[2][2], aux2[2][2];
while (m--) {
cin >> x >> y;
--x;
--y;
int c1 = x % n, c2 = y % n;
int b1 = (x < n ? 0 : 1), b2 = (y < n ? 0 : 1);
if (c2 < c1) {
swap(c1, c2);
swap(b1, b2);
}
for (int b1 = 0; b1 <= 1; ++b1)
for (int b2 = 0; b2 <= 1; ++b2) aux[b1][b2] = dp[0][c1][b1][b2];
int L = c2 - c1, L2 = 1;
while (L) {
int x = __builtin_ctz(L);
L ^= (1 << x);
for (int b1 = 0; b1 <= 1; ++b1)
for (int b2 = 0; b2 <= 1; ++b2)
aux2[b1][b2] = solve(aux[b1][0], dp[x][c1 + L2][0][b2], aux[b1][1],
dp[x][c1 + L2][1][b2]);
L2 += (1 << x);
for (int b1 = 0; b1 <= 1; ++b1)
for (int b2 = 0; b2 <= 1; ++b2) aux[b1][b2] = aux2[b1][b2];
}
cout << aux[b1][b2] << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = 1000010;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
int a[n];
int p, x;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long int q;
cin >> q;
int time[n];
memset(time, 0, sizeof(time));
int update[q];
for (long long int i = 0; i < q; ++i) {
update[i] = -1;
long long int t;
cin >> t;
if (t == 1) {
cin >> p >> x;
a[p - 1] = x;
time[p - 1] = i;
} else if (t == 2) {
cin >> x;
update[i] = x;
}
}
for (int i = q - 2; i >= 0; i--) {
update[i] = max(update[i], update[i + 1]);
}
for (int i = 0; i < n; ++i) {
a[i] = max(a[i], update[time[i]]);
}
for (int i = 0; i < n; ++i) {
cout << a[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int aa[27], bb[1000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k = 0, i;
cin >> n;
string s;
cin >> s;
if (n == 1) {
cout << "YES" << endl;
cout << s << endl;
return 0;
}
for (int i = 0; i < s.size(); i++) {
aa[s[i] - 'a']++;
if (aa[s[i] - 'a'] == 1) k++;
}
if (k < n)
cout << "NO" << endl;
else {
cout << "YES" << endl;
int p = 0;
for (int i = 0; i < s.size(); i++) {
if (!bb[s[i]] && p < n) {
cout << endl;
bb[s[i]] = 1;
p++;
}
cout << s[i];
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e14;
struct MaxQueue {
deque<long long> Q;
deque<long long> falling;
void push(long long x) {
Q.push_back(x);
while (!falling.empty() && falling.back() < x) falling.pop_back();
falling.push_back(x);
}
void pop() {
long long front = Q.front();
Q.pop_front();
if (front == falling.front()) falling.pop_front();
}
void clear() {
falling.clear();
Q.clear();
}
long long get_max() { return falling.empty() ? -inf : falling.front(); }
};
int main(void) {
cin.sync_with_stdio(false);
int n_len, n_works;
long long d;
cin >> n_len >> n_works >> d;
const int MAXLEN = 15e4 + 123;
static long long dp[2][MAXLEN];
memset(dp[0], 0, sizeof dp[0]);
int last_t = 1;
for (int iter = 0; iter < (n_works); ++iter) {
long long bonus, sred, t;
cin >> sred >> bonus >> t;
--sred;
int delta = t - last_t;
for (int i = 0; i < (n_len); ++i) dp[1][i] = -inf;
int ul = 0, ur = 0;
static MaxQueue Q;
Q.clear();
for (int i = 0; i < (n_len); ++i) {
int l = max<long long>(0, i - delta * d);
int r = min<long long>(n_len, i + delta * d + 1);
while (ur < r) {
Q.push(dp[0][ur]);
++ur;
}
while (ul < l) {
Q.pop();
++ul;
}
dp[1][i] = Q.get_max() + bonus - llabs(sred - i);
}
for (int i = 0; i < (n_len); ++i) dp[0][i] = dp[1][i];
last_t = t;
}
long long maks = -inf;
for (int i = 0; i < (n_len); ++i) maks = max(maks, dp[0][i]);
cout << maks << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int bit[N], n, m, k;
int get(int idx) {
int ret = 0;
while (idx > 0) {
ret += bit[idx];
idx -= idx & -idx;
}
return ret;
}
void update(int idx, int val) {
while (idx <= n) {
bit[idx] += val;
idx += idx & -idx;
}
}
struct event {
long long t;
int house, idx;
bool person;
event(int pos, long long a, int b, bool c) {
idx = pos;
t = a;
house = b;
person = c;
}
};
bool operator<(event a, event b) {
if (a.t != b.t) return a.t < b.t;
if (a.person != b.person) return a.person < b.person;
if (a.idx != b.idx) return a.idx < b.idx;
if (a.house != b.house) return a.house != b.house;
return 0;
}
priority_queue<pair<long long, long long> > q[N];
queue<pair<long long, long long> > waiting;
pair<long long, long long> sol[N];
int a[N], b[N];
int get_closest(int idx) {
int low = 0, high = n + 1;
while (low + 1 < high) {
int mid = (low + high) / 2;
int lft = get(idx + 1) - get(max(0, idx - mid - 1));
int rgt = get(min(n, idx + mid)) - get(idx - 1);
if (lft > 0 || rgt > 0)
high = mid;
else
low = mid + 1;
}
int cur = get(idx);
int lft = get(idx) - get(max(0, idx - low - 1));
int rgt = get(min(n, idx + low)) - get(idx - 1);
if (lft > 0 || rgt > 0) return low;
return high;
}
set<event> st;
void solve(int idx, long long late, int qidx, long long t) {
pair<long long, long long> top = q[qidx].top();
q[qidx].pop();
top.first *= -1;
top.second *= -1;
update(qidx, -1);
sol[idx] = pair<long long, long long>(late, top.second);
st.insert(event(top.second, t + abs(b[idx] - a[idx]) + abs(a[idx] - qidx),
b[idx], 0));
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
int a;
scanf("%d", &a);
update(a, 1);
q[a].push(pair<long long, long long>(0, -i));
}
for (int i = 0; i < m; i++) {
long long tim;
cin >> tim >> a[i] >> b[i];
st.insert(event(i, tim, a[i], 1));
}
int sum = 0;
while (sum < m && !st.empty()) {
event x = *st.begin();
vector<event> v;
long long curT = x.t;
while (!st.empty() && (*st.begin()).t == x.t) {
v.push_back(*st.begin());
st.erase(st.begin());
}
int i = 0;
while (i < v.size() && v[i].person == 0) {
int idx = v[i].house;
int id = v[i].idx;
q[idx].push(pair<long long, long long>(-curT, -id));
update(idx, 1);
i++;
}
for (; i < v.size(); i++) {
int id = v[i].idx;
long long arrival = v[i].t;
waiting.push(pair<long long, long long>(arrival, id));
}
while (!waiting.empty() && get(n) > 0) {
sum++;
pair<long long, long long> cur = waiting.front();
waiting.pop();
int idx = a[cur.second], pos = get_closest(a[cur.second]);
int rgt = pos + idx, lft = idx - pos;
long long late = curT - cur.first;
bool golft = 0, gorgt = 0;
if (lft > 0 && !q[lft].empty() > 0) golft = 1;
if (rgt <= n && !q[rgt].empty() > 0) gorgt = 1;
if (pos == 0) golft = 0;
if (gorgt && golft) {
pair<long long, long long> a = q[lft].top();
pair<long long, long long> b = q[rgt].top();
a.first *= -1;
b.first *= -1;
a.second *= -1;
b.second *= -1;
int taken = 0;
if (a.first != b.first) {
if (a.first > b.first) taken = 1;
} else {
if (a.second > b.second) taken = 1;
}
solve(cur.second, late + pos, taken == 1 ? rgt : lft, curT);
} else if (gorgt) {
solve(cur.second, late + pos, rgt, curT);
} else if (golft) {
solve(cur.second, late + pos, lft, curT);
} else
cout << "ERROR\n";
}
}
for (int i = 0; i < m; i++) {
printf("%I64d %I64d\n", sol[i].second, sol[i].first);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int q, sq, ctr, lens;
string s, res;
bool check() {
int lenr = res.size();
string wynik;
for (int i = 0; i < lenr; i++) {
if (res[i] == 'H')
wynik += 'H';
else
for (int j = 0; j < lenr; j++) wynik += res[j];
if (wynik.size() > 1000 * 1000) break;
}
return wynik == s;
}
int main() {
cin >> s;
lens = s.size();
for (int i = 0; i < lens; i++)
if (s[i] == 'Q') q++;
if (q == 0) {
printf("Yes\n");
return 0;
}
sq = sqrt(q);
if (sq * sq != q) {
printf("No\n");
return 0;
}
for (int i = 0; i < lens; i++) {
if (s[i] == 'Q') break;
ctr++;
}
if (ctr & 1) {
printf("No\n");
return 0;
}
for (int i = 0; i < ctr / 2; i++) res += 'H';
for (int i = ctr; i < lens && sq; i++) {
if (s[i] == 'Q') sq--;
res += s[i];
}
ctr = 0;
for (int i = lens - 1; s[i] != 'Q'; i--) ctr++;
if (ctr & 1) {
printf("No\n");
return 0;
}
for (int i = 0; i < ctr / 2; i++) res += 'H';
if (check()) {
printf("Yes\n");
return 0;
}
printf("No\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, y, a, b, c, d;
cin >> y;
while (1) {
y = y + 1;
a = y / 1000;
b = y / 100 % 10;
c = y / 10 % 10;
d = y % 10;
if (a != b && a != c && a != d && b != c && b != d && c != d) {
break;
}
}
cout << y << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a[200001];
long long T[200001];
set<int> S[30 + 1];
int MSB(int x) {
if (x == 0) {
return 30;
}
int k;
for (k = 30 - 1; k > -1 && (x & (1 << k)) == 0; --k)
;
return k;
}
void BITUpdate(int i, int x) {
if (i == 0) {
return;
}
for (; i <= n; i += (i & -i)) T[i] += x;
}
long long BITQuery(int i) {
long long ans = 0;
for (; i > 0; i -= (i & -i)) ans += T[i];
return ans;
}
void Update(int i, int x) {
if (x == a[i]) {
return;
}
int curMSB = MSB(a[i]), newMSB = MSB(x);
if (curMSB != newMSB) {
S[curMSB].erase(i);
S[newMSB].insert(i);
}
BITUpdate(i, x - a[i]);
a[i] = x;
}
int Query() {
if (S[30].size() > 0 && *S[30].begin() == 1) {
return 1;
}
for (int k = 0; k < 30; ++k) {
int c = 0;
for (auto i : S[k]) {
++c;
if (BITQuery(i - 1) == a[i]) {
return i;
}
if (c == 2) {
break;
}
}
}
return -1;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
S[30].insert(i);
Update(i, x);
}
while (q--) {
int i, x;
scanf("%d%d", &i, &x);
Update(i, x);
printf("%d\n", Query());
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char get(char ch) {
int x = ch - '0';
x--;
return (char)(x + '0');
}
void solve(string s) {
int cur = 0, d = 1;
int cnt[10];
memset(cnt, 0, sizeof(cnt));
for (int it = 1; it <= 1e5; it++) {
if (cur == -1 || cur >= (int)s.size()) {
break;
}
if (isdigit(s[cur])) {
cnt[s[cur] - '0']++;
if (s[cur] == '0') {
s.erase(s.begin() + cur);
if (d == 0) {
cur--;
}
} else {
s[cur] = get(s[cur]);
if (d == 0) {
cur--;
} else {
cur++;
}
}
} else if (s[cur] == '>') {
d = 1;
cur++;
if (cur < (int)s.size() && !isdigit(s[cur])) {
cur--;
s.erase(s.begin() + cur);
}
} else {
d = 0;
cur--;
if (cur >= 0 && !isdigit(s[cur])) {
s.erase(s.begin() + cur + 1);
}
}
}
for (int i = 0; i < 10; i++) {
cout << cnt[i] << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n >> q;
string s;
cin >> s;
while (q--) {
int l, r;
cin >> l >> r;
l--;
r--;
solve(s.substr(l, r - l + 1));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[2004];
long long d[2004];
int b[2004];
int fac[2004];
const int mod = 1e9 + 7;
long long qk(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int main() {
int n;
d[0] = 1;
d[1] = 0;
d[2] = 1;
for (int i = 3; i <= 2000; ++i) {
d[i] = (d[i - 1] + d[i - 2]) % mod * (i - 1) % mod;
}
for (int i = 0; i <= 2000; ++i) {
b[i] = 1;
}
fac[1] = 1;
fac[0] = 1;
for (int i = 2; i <= 2000; ++i) {
fac[i] = fac[i - 1] * i % mod;
}
scanf("%d", &n);
int ok = 0;
if (n == 1000) ok = 1;
int len = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
if (a[i] == -1) {
len++;
b[i + 1]++;
} else
b[a[i]]--;
}
long long cnt = 0;
for (int i = 1; i <= n; ++i) {
if (b[i] == 1) cnt++;
}
cnt /= 2;
long long base = 1;
long long ans = 0;
for (int i = 0; i <= cnt; ++i) {
ans = (ans + d[len - i] * base % mod) % mod;
base = base * (cnt - i) % mod * qk(i + 1, mod - 2) % mod;
}
printf("%lld\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int n;
cin >> n;
deque<int> a;
int p = 1;
int ats = 0;
for (int i = 0; i < 2 * n; i++) {
string x;
cin >> x;
if (x[0] == 'a') {
int y;
cin >> y;
a.push_back(y);
} else {
if (a.size() == 0) {
p++;
continue;
} else if (a.back() == p++)
a.pop_back();
else {
ats++;
a.clear();
}
}
}
cout << ats;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 9, M = 1e2 + 3, MOD = 1e9 + 7;
const long long INF = 1e15;
vector<int> adj[N];
int sz[N], ans[N], mx[N], parent[N];
set<pair<int, int>> st[N];
void pre(int node, int par) {
sz[node]++;
parent[node] = par;
for (auto it : adj[node]) {
if (it == par) continue;
pre(it, node);
sz[node] += sz[it];
st[node].insert({sz[it], it});
}
}
void dfs(int node, int par) {
int bigChild = -1;
for (auto it : adj[node]) {
if (it == par) continue;
if (bigChild == -1 || sz[it] > sz[bigChild]) bigChild = it;
}
if (bigChild != -1) {
dfs(bigChild, node);
swap(st[bigChild], st[node]);
}
for (auto it : adj[node]) {
if (it == par || it == bigChild) continue;
dfs(it, node);
}
st[node].insert({sz[node], node});
auto it = st[node].lower_bound({sz[node] / 2 + (sz[node] % 2), 0});
if (it != st[node].end()) ans[node] = (*it).second;
}
void runtestcase() {
int n, q, x;
cin >> n >> q;
ans[1] = 1;
for (int i = 2; i <= n; ++i) {
ans[i] = i;
cin >> x;
adj[i].push_back(x);
adj[x].push_back(i);
}
pre(1, 1);
dfs(1, 1);
while (q--) {
cin >> x;
cout << ans[x] << '\n';
}
}
int main() {
cout << fixed << setprecision(6), ios::sync_with_stdio(false),
cin.tie(nullptr), cout.tie(nullptr);
int t = 1, tt = 1;
while (t) {
runtestcase();
--t, ++tt;
}
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long n;
scanf("%lld", &n);
long long fact = 1;
long long temp = n;
while (temp != 0) {
fact *= temp;
temp--;
}
fact = (fact * 2) / (n * n);
printf("%lld\n", fact);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int dr4[] = {1, 0, -1, 0}, dc4[] = {0, -1, 0, 1};
int dr8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dc8[] = {0, -1, -1, -1, 0, 1, 1, 1};
using namespace std;
int n, m, q, dx[10], dy[10], nxt[205 * 205][10];
bool vis[205][205];
char s[205][205], tmp[1000009];
vector<int> start;
int pos(int x, int y) { return x * m + y; }
bool valid(int xx, int yy) { return (xx >= 0 && xx < n && yy >= 0 && yy < m); }
void dfs(int x, int y) {
vis[x][y] = 1;
int u = pos(x, y);
int d = s[x][y] - '0';
int xx = x + dx[d], yy = y + dy[d];
if (valid(xx, yy)) {
int v = pos(xx, yy);
nxt[u][d] = v;
if (!vis[xx][yy]) dfs(xx, yy);
for (int i = 0; i < 10; i++) {
if (i != d) nxt[u][i] = nxt[v][i];
}
} else
nxt[u][d] = u;
}
bool query() {
for (int i = 0; i < start.size(); i++) {
int u = start[i];
int len = strlen(tmp);
for (int j = 0; j < len && u != -1; j++) {
int nx = tmp[j] - '0';
u = nxt[u][nx];
}
if (u != -1) return 1;
}
return 0;
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < 10; i++) cin >> dx[i] >> dy[i];
memset(nxt, -1, sizeof nxt);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (vis[i][j]) continue;
dfs(i, j);
start.push_back(pos(i, j));
}
}
for (int i = 0; i < q; i++) {
scanf("%s", tmp);
if (query())
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 8 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long LL;
const int N = 100010, M = N << 1, mod = 1e9 + 7;
char s[N], str[] = "tryhub";
int cnt[26];
int main()
{
int _;
scanf("%d", &_);
while(_ --)
{
int n;
scanf("%d%s", &n, s);
for(int i = 0; s[i]; i ++) cnt[s[i] - 'a'] ++;
while(cnt[1]) putchar('b'), cnt[1] --;
for(int i = 0; i < 26; i ++)
while(cnt[i])
{
putchar(i + 'a');
cnt[i] --;
}
puts("");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, kk, q, ans, cnt, nc, a[N], b[N], c[N], pre[N], bl[N], lt[N], tag[N];
char s[N];
int num[1007][17000];
void upd1(int p, int v) {
for (int i = p; i <= n; i += kk) {
pre[i] ^= v;
if (v && !pre[i]) --ans;
if (v && pre[i] == v) ++ans;
}
int lst = p % kk + ((n - p % kk) / kk) * kk;
if (v && !pre[lst]) --cnt;
if (v && pre[lst] == v) ++cnt;
}
void upd2(int p, int v) {
for (int i = p; bl[i] == bl[p]; i += kk) {
if (v && !(pre[i] ^ tag[bl[p]])) ++ans;
num[bl[p]][pre[i]]--;
pre[i] ^= v;
num[bl[p]][pre[i]]++;
if (v && !(pre[i] ^ tag[bl[p]])) --ans;
}
for (int i = bl[p] + 1; i <= nc && lt[i] % kk == p % kk; i++) {
if (v) ans += num[i][tag[i]];
tag[i] ^= v;
if (v) ans -= num[i][tag[i]];
}
int lst = p % kk + ((n - p % kk) / kk) * kk;
if (v && !(pre[lst] ^ tag[bl[lst]])) --cnt;
if (v && (pre[lst] ^ tag[bl[lst]]) == v) ++cnt;
}
const int B = 400;
void modify(int p, int v) {
if (n / kk < B)
upd1(p, v ^ c[p]);
else
upd2(p, v ^ c[p]);
c[p] = v;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> kk >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
++n;
if (n / kk >= B)
for (int i = 1; i <= kk; i++)
for (int j = i; j <= n; j += kk) {
if (((j - 1) / kk + 1) % B == 1) {
lt[++nc] = j;
num[nc][0] = min(B, (n - j) / kk + 1);
}
bl[j] = nc;
}
for (int i = 1; i <= n; i++) modify(i, (a[i] ^ a[i - 1]) ^ (b[i] ^ b[i - 1]));
cout << (cnt ? -1 : ans) << endl;
while (q--) {
int p, v;
cin >> s >> p >> v;
if (s[0] == 'a')
a[p] = v;
else
b[p] = v;
modify(p, (a[p] ^ a[p - 1]) ^ (b[p] ^ b[p - 1]));
if (p != n) modify(p + 1, (a[p + 1] ^ a[p]) ^ (b[p + 1] ^ b[p]));
cout << (cnt ? -1 : ans) << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
char ch[4000010];
inline string get() {
scanf("%s", ch);
return string(ch);
}
inline void read(int *a, int n) {
for (int i = 0; i < n; i++) a[i] = in();
}
template <class blank>
inline void out(blank x) {
cout << x << "\n";
exit(0);
}
template <class blank, class blank2>
inline void smin(blank &a, blank2 b) {
a = a <= b ? a : b;
}
template <class blank, class blank2>
inline void smax(blank &a, blank2 b) {
a = a >= b ? a : b;
}
const int maxn = 1e3 + 10;
const int maxm = 4e6 + 10;
const int maxlg = 20;
const int base = 29;
const int mod = 1e9 + 7;
const long long inf = 1e9 + 10;
const double eps = 1e-4;
int a[maxn], b[maxn];
vector<int> g[maxn];
bool mark[maxn];
int f, s;
vector<int> V[maxn];
int where[maxn];
int cmp;
int q[maxn], t, h, di[maxn], pre[maxn];
inline void bfs(int node) {
t = 1, h = 0;
q[0] = node;
for (int i = 0; i <= 310; i++) di[i] = inf;
di[node] = 0;
while (h < t) {
int v = q[h++];
for (auto u : g[v]) {
if (di[u] >= inf) {
di[u] = di[v] + 1, q[t++] = u;
pre[u] = v;
}
}
}
}
vector<int> path;
int from[maxn * maxn * 2], to[maxn * maxn * 2], val[maxn * maxn * 2], sz;
inline void add(int f, int t, int v) {
from[sz] = f, to[sz] = t, val[sz] = v, sz++;
}
inline void push(int source, int target, int value) {
if (source == target) return;
int pr = pre[target];
int VAL = min(a[pr], value);
a[pr] -= VAL, a[target] += VAL;
add(pr, target, VAL);
push(source, pr, value);
a[pr] -= value - VAL;
a[target] += value - VAL;
if (value - VAL) add(pr, target, value - VAL);
}
int32_t main() {
int n = in(), v = in(), e = in();
read(a, n);
read(b, n);
for (int i = 0; i < e; i++) {
int v = in() - 1, u = in() - 1;
g[v].push_back(u), g[u].push_back(v);
}
for (int v = 0; v < n; v++) {
if (a[v] <= b[v]) continue;
bfs(v);
for (int u = 0; u < n; u++) {
if (di[u] >= inf) continue;
if (a[u] >= b[u]) continue;
int val = min(a[v] - b[v], b[u] - a[u]);
if (val == 0) break;
push(v, u, val);
}
}
for (int i = 0; i < n; i++)
if (a[i] != b[i]) out("NO\n");
cout << sz << "\n";
for (int i = 0; i < sz; i++) {
printf("%d %d %d\n", from[i] + 1, to[i] + 1, val[i]);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[200007], b[200007];
char ans[200007];
int n, k;
int main() {
cin >> n >> k;
for (int(i) = 0; (i) < (int)(n); (i)++) {
cin >> a[i];
a[i]--;
}
for (int(i) = 0; (i) < (int)(n); (i)++) {
cin >> b[i];
b[i]--;
}
set<int> s1, s2;
vector<int> v;
for (int(i) = 0; (i) < (int)(n); (i)++) {
int p = a[i], q = b[i];
if (s2.count(p))
s2.erase(p);
else
s1.insert(p);
if (s1.count(q))
s1.erase(q);
else
s2.insert(q);
if (s1.empty() && s2.empty()) v.push_back(i);
}
if (v.size() < k) {
cout << "NO" << endl;
exit(0);
}
int l = 0, r = 0;
char cur = 'a';
for (int(i) = 0; (i) < (int)(v.size()); (i)++) {
r = v[i];
for (int j = l; j <= r; j++) {
ans[a[j]] = cur;
}
l = r + 1;
cur = min(char(cur + 1), 'z');
}
cout << "YES" << endl;
puts(ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T;
cin >> T;
while (T--) {
long long a, b;
cin >> a >> b;
if (a < b) swap(a, b);
long long count = 0;
while (a != b) {
count += (a / b);
long long remain = (a % b);
if (remain == 0)
break;
else
a = remain;
if (a < b) swap(a, b);
}
if (count == 0)
cout << 1;
else
cout << count;
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pci = pair<char, int>;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
const ll infll = 1e18 + 3;
const int maxn = 1e6 + 77;
const int nmax = 1e6 + 577;
const ll basell = 1e18 + 3;
const int mod = 1e9 + 7;
const ld eps = 1e-7;
const int inf = 1009000999;
const int nv = 100505;
const int baseint = 1000200013;
const ld PI = acos(-1.0);
inline bool EQ(ld a, ld b) { return fabs(a - b) < 1e-9; }
inline bool IF(int a, int b, int c) { return (a >= b && a <= c); }
inline bool IFS(int a, int b, int c) { return (a > b && a < c); }
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) {
_in >> _i;
}
return _in;
}
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
vi g[nv];
int siz[nv];
pii indx[nv];
map<int, vpii> pred;
int inline solve() {
ios::sync_with_stdio(NULL), cin.tie(NULL), cout.tie(NULL);
;
int n, m;
cin >> n >> m;
int sum = 0;
for (int i = 0; i < n; ++i) {
int s;
cin >> s;
sum += s;
indx[i] = {s, i};
siz[i] = s;
for (int j = 0; j < s; ++j) {
int a;
cin >> a;
g[a - 1].push_back(i);
}
}
sort(indx, indx + n);
vector<pair<pii, int>> ans;
vector<int> d(n);
for (int i = 0; i < n; i++) {
d[indx[i].second] = sum / (n - i);
sum -= d[indx[i].second];
}
vi small;
for (int i = 0; i < n; ++i) {
if (siz[i] < d[i]) {
small.push_back(i);
}
}
vi z(n, -1);
for (int i = 0; i < m; ++i) {
vi big;
for (int x : g[i]) {
z[x] = i;
if (siz[x] > d[x]) {
big.push_back(x);
}
}
int j = 0;
for (int x : big) {
while (j < ((int)(small).size()) && z[small[j]] == i) j++;
if (j >= ((int)(small).size())) break;
int &y = small[j];
ans.push_back({{x, y}, i});
siz[x]--;
siz[y]++;
if (siz[y] == d[y]) {
swap(y, small.back());
small.pop_back();
} else {
j++;
}
}
}
cout << ((int)(ans).size()) << '\n';
for (auto i : ans) {
cout << i.first.first + 1 << " " << i.first.second + 1 << " "
<< i.second + 1 << '\n';
}
return 0;
}
int32_t main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= (ch == '-'), ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
long long n, now[4][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
inline long long find(long long x, long long y) {
return (x / 4) * (n / 4) + y / 4 + 1;
}
signed main() {
n = read();
for (register long long i = 0; i <= n - 1; i++) {
for (register long long j = 0; j <= n - 1; j++) {
long long at = find(i, j);
cout << (at - 1) * 16 + now[i % 4][j % 4] << " ";
}
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool readInteger(T& x) {
char c, r = 0, n = 0;
x = 0;
for (;;) {
c = getchar();
if ((c < 0) && (!r))
return (0);
else if ((c == '-') && (!r))
n = 1;
else if ((c >= '0') && (c <= '9'))
x = x * 10 + c - '0', r = 1;
else if (r)
break;
}
if (n) x = -x;
return (1);
}
const int MOD = 1000000007;
long long modPow(long long a, long long b, int mod) {
assert(b >= 0);
long long ret = 1 % mod;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
const int MX = 1.1e6;
char s1[MX], s2[MX];
int n;
char invert(char c) {
switch (c) {
case 'N':
return 'S';
case 'S':
return 'N';
case 'W':
return 'E';
case 'E':
return 'W';
default:
assert(false);
}
}
void rev(char* s, bool inv) {
assert(strlen(s) == n);
reverse(s, s + n);
if (inv)
for (int i = (0); i < int(n); i++) s[i] = invert(s[i]);
}
int f[MX];
bool check() {
f[0] = f[1] = 0;
for (int i = (2); i < int(n + 1); i++) {
f[i] = f[i - 1];
while (true) {
if (s1[f[i]] == s1[i - 1]) {
++f[i];
break;
}
if (f[i] == 0) break;
f[i] = f[f[i]];
}
}
for (int i = (0); i < int(n); i++) s2[i] = invert(s2[i]);
reverse(s2, s2 + n);
int i = 0;
int j = 0;
while (true) {
if (j == n) return i == 0;
if (s2[j] == s1[i])
i++, j++;
else if (i > 0)
i = f[i];
else
j++;
}
}
bool solve() {
readInteger(n);
--n;
scanf("%s%s", s1, s2);
rev(s1, false);
rev(s2, false);
return check();
}
int main() { printf("%s\n", solve() ? "YES" : "NO"); }
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long sum = 0;
for (int j = 0; j < n; j++) {
if (j == 0) {
sum += a[0] * (n - a[0] + 1);
continue;
}
if (a[j] > a[j - 1]) {
sum += (a[j] - a[j - 1]) * (n - a[j] + 1);
} else if (a[j - 1] > a[j]) {
sum += a[j] * (a[j - 1] - a[j]);
}
}
cout << sum << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char ans[4000000], ds[10];
int d[5][600][600], dx[10], dy[10], n, xl, yl, p = 0, a[600][600];
bool was[600][600], wasx[600], wasy[600];
void dfs(int x, int y) {
was[x][y] = true;
wasx[x] = true;
wasy[y] = true;
if (a[x][y] == 0) {
p++;
ans[p] = '1';
} else {
a[x][y] = 0;
for (int i = 1; i <= n; i++) d[1][i][y] = d[1][i - 1][y] + a[i][y];
for (int i = n; i > 0; i--) d[2][i][y] = d[2][i + 1][y] + a[i][y];
for (int i = 1; i <= n; i++) d[3][x][i] = d[3][x][i - 1] + a[x][i];
for (int i = n; i > 0; i--) d[4][x][i] = d[4][x][i + 1] + a[x][i];
}
for (int k = 1; k <= 4; k++)
if (!was[x + dx[k]][y + dy[k]] && d[k][x + dx[k]][y + dy[k]] > 0) {
p++;
ans[p] = ds[k];
dfs(x + dx[k], y + dy[k]);
p++;
ans[p] = '2';
a[x + dx[k]][y + dy[k]] = 0;
p++;
if (k % 2 == 0)
ans[p] = ds[k - 1];
else
ans[p] = ds[k + 1];
was[x + dx[k]][y + dy[k]] = false;
wasx[x + dx[k]] = false;
wasy[y + dy[k]] = false;
}
}
int main() {
cin >> n >> xl >> yl;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> a[i][j];
for (int k = 1; k <= 4; k++)
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= n + 1; j++) d[k][i][j] = 0;
dx[1] = -1;
dx[2] = 1;
dx[3] = 0;
dx[4] = 0;
dy[1] = 0;
dy[2] = 0;
dy[3] = -1;
dy[4] = 1;
ds[1] = 'U';
ds[2] = 'D';
ds[3] = 'L';
ds[4] = 'R';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[1][i][j] = d[1][i - 1][j] + a[i][j];
for (int i = n; i > 0; i--)
for (int j = 1; j <= n; j++) d[2][i][j] = d[2][i + 1][j] + a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[3][i][j] = d[3][i][j - 1] + a[i][j];
for (int i = 1; i <= n; i++)
for (int j = n; j > 0; j--) d[4][i][j] = d[4][i][j + 1] + a[i][j];
dfs(xl, yl);
a[xl][yl] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] == 1) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 1; i <= p; i++) cout << ans[i];
cout << "2";
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int mod = ((1E9) + 7);
const int intmax = ((1E9) + 7);
using namespace std;
int n;
string s[105];
vector<int> ans;
queue<int> q;
int aa[105];
void bfs() {
while (!q.empty()) {
auto u = q.front();
q.pop();
;
ans.push_back(u);
for (int i = 0; i < n; i++) {
if (u != i && s[u][i] == '1') {
aa[i]--;
if (aa[i] == 0) q.push(i);
}
}
}
}
int main() {
int test, a, b, c;
scanf("%d", &n);
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
scanf("%d", &aa[i]);
if (aa[i] == 0) q.push(i);
}
bfs();
cout << ans.size() << endl;
for (auto u : ans) cout << u + 1 << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int find_pow(int x, int y) {
int g = 1;
while (y) {
if (y & 1) g = ((long long)g * x) % 1000000007;
y >>= 1;
x = ((long long)x * x) % 1000000007;
}
return g;
}
int main() {
char ch[100005];
int k;
scanf("%s %d", ch, &k);
int x = 0, t = 1;
int l = strlen(ch);
for (int i = 0; i < l; ++i) {
if (ch[i] == '0' || ch[i] == '5') {
x = (x + t) % 1000000007;
}
t = (t * 2) % 1000000007;
}
int c = t;
t--;
if (t < 0) t += 1000000007;
c = find_pow(c, k) - 1;
if (c < 0) c += 1000000007;
x = ((long long)x * c) % 1000000007;
x = ((long long)x * find_pow(t, 1000000007 - 2)) % 1000000007;
printf("%d\n", x);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, ans = 0, kol = 0, a, p, m;
int main() {
scanf("%d", &n);
m = -1;
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &p);
if (m == -1)
m = p;
else if (p < m) {
ans += (kol * m);
m = p;
kol = 0;
}
kol += a;
}
ans += (kol * m);
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) { return a == 0 ? b : GCD(b % a, a); }
string ntoa(int b) {
string a = "";
while (b) {
a += (b % 10 + '0');
b /= 10;
}
reverse(a.begin(), a.end());
return a;
}
struct myitem {
int h;
int w;
myitem(int a, int b) {
h = a;
w = b;
if (h > w) {
int t = h;
h = w;
w = t;
}
}
};
bool mycompare(myitem a, myitem b) {
if (a.h == b.h) return a.w < b.w;
return a.h < b.h;
}
int findrep(int a, int *representative) {
if (representative[a] != a) {
return representative[a] = findrep(representative[a], representative);
} else {
return a;
}
}
void unionfind(int x, int y, int *representative) {
int xp, yp;
xp = findrep(x, representative);
yp = findrep(y, representative);
representative[yp] = xp;
}
class Graph {
int V;
list<int> *adj;
bool isCyclicUtil(int v, bool visited[], bool *rs);
public:
Graph(int V);
void addEdge(int v, int w);
bool isCyclic();
};
Graph::Graph(int V) {
this->V = V;
adj = new list<int>[V];
}
void Graph::addEdge(int v, int w) { adj[v].push_back(w); }
bool Graph::isCyclicUtil(int v, bool visited[], bool *recStack) {
if (visited[v] == false) {
visited[v] = true;
recStack[v] = true;
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i) {
if (!visited[*i] && isCyclicUtil(*i, visited, recStack))
return true;
else if (recStack[*i])
return true;
}
}
recStack[v] = false;
return false;
}
bool Graph::isCyclic() {
bool *visited = new bool[V];
bool *recStack = new bool[V];
for (int i = 0; i < V; i++) {
visited[i] = false;
recStack[i] = false;
}
for (int i = 0; i < V; i++)
if (isCyclicUtil(i, visited, recStack)) return true;
return false;
}
int setbit(int N, int pos) { return N = N | (1 << pos); }
int resetbit(int N, int pos) { return N = N & (~(1 << pos)); }
int checkbit(int N, int pos) { return N & (1 << pos); }
int countsets(int N) {
int a = 0;
for (int i = 1; i <= N; i <<= 1) {
if (N & i) a++;
}
return a;
}
int numbers[1000005];
int tfreq[1000005];
int main() {
for (int i = 0; i < 1000005; ++i) {
tfreq[i] = 0;
}
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &numbers[i]);
}
int difnum = 0;
int bp = 0;
int fp = -1;
int mxl = -1;
int l = -1;
int r = -1;
int fflag = 1;
while (bp < n && fp < n - 1) {
if (difnum <= k && fflag) {
fp++;
if (tfreq[numbers[fp]] == 0) {
difnum++;
}
tfreq[numbers[fp]]++;
if (difnum <= k) {
if ((fp - bp + 1) > mxl) {
mxl = fp - bp + 1;
l = bp + 1;
r = fp + 1;
}
} else if (difnum > k) {
tfreq[numbers[fp]]--;
if (tfreq[numbers[fp]] == 0) difnum--;
fp--;
fflag = 0;
}
} else if (fflag == 0) {
tfreq[numbers[bp]]--;
if (tfreq[numbers[bp]] == 0) {
difnum--;
}
bp++;
if (difnum < k) {
fflag = 1;
}
}
}
printf("%d %d\n", l, r);
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.