solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
struct Point {
int x, y;
Point(int x = 0, int y = 0) : x(x), y(y) {}
Point operator-(const Point& R) const { return Point(x - R.x, y - R.y); }
long long operator^(const Point& R) const {
return (long long)x * R.y - (long long)y * R.x;
}
};
Point p[N];
int n;
bool used[N];
char str[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &p[i].x, &p[i].y);
}
scanf("%s", str);
vector<int> res;
int cur = 0;
for (int i = 1; i < n; ++i) {
if (make_pair(p[i].x, p[i].y) < make_pair(p[cur].x, p[cur].y)) {
cur = i;
}
}
used[cur] = 1;
res.emplace_back(cur);
auto findLeft = [&](Point P) {
int x = -1;
for (int i = 0; i < n; ++i) {
if (!used[i] && (!~x || ((p[i] - P) ^ (p[x] - P)) < 0)) {
x = i;
}
}
return x;
};
auto findRight = [&](Point P) {
int x = -1;
for (int i = 0; i < n; ++i) {
if (!used[i] && (!~x || ((p[i] - P) ^ (p[x] - P)) > 0)) {
x = i;
}
}
return x;
};
for (int i = 0; i < n - 2; ++i) {
int nxt;
if (str[i] == 'L') {
nxt = findRight(p[cur]);
} else {
nxt = findLeft(p[cur]);
}
used[nxt] = 1;
cur = nxt;
res.emplace_back(nxt);
}
res.emplace_back(findRight(p[cur]));
for (int i = 0; i < n; ++i) {
printf("%d%c", res[i] + 1, " \n"[i + 1 == n]);
}
}
| 9 |
#include <bits/stdc++.h>
int main() {
int a = 0;
int b = 0;
int c = 0;
int d = 0;
int e = 0;
int max1 = 0;
int max2 = 0;
int max = 0;
int n, m;
int sum = 0;
scanf("%d%d", &n, &m);
char option[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf(" %c", &option[i][j]);
}
int marks[m];
for (int i = 0; i < m; i++) scanf("%d", &marks[i]);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (option[j][i] == 'A')
a++;
else if (option[j][i] == 'B')
b++;
else if (option[j][i] == 'C')
c++;
else if (option[j][i] == 'D')
d++;
else if (option[j][i] == 'E')
e++;
}
if (a >= b)
max1 = a;
else
max1 = b;
if (c >= d)
max2 = c;
else
max2 = d;
if (max1 >= max2)
max = max1;
else
max = max2;
if (max < e) max = e;
a = 0;
b = 0;
c = 0;
d = 0;
e = 0;
sum = sum + (max * marks[i]);
}
printf("%d", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
long long A[2] = {234234234, 987654321}, Apow[2][100005];
int P[2] = {1000000007, 1000000009};
void init() {
for (int t = (0); t < (2); t++) {
Apow[t][0] = 1;
for (int i = (1); i < (100005); i++) {
Apow[t][i] = Apow[t][i - 1] * A[t] % P[t];
}
}
}
void hashit(int n, char str[100005], int hstr[2][100005]) {
for (int t = (0); t < (2); t++) {
for (int i = (0); i < (n); i++) {
hstr[t][i] = (i ? hstr[t][i - 1] : 0) * A[t] % P[t] + (str[i] - 'a' + 1);
if (hstr[t][i] >= P[t]) hstr[t][i] -= P[t];
}
}
}
pair<int, int> gethash(int hstr[2][100005], int l, int r) {
int h[2] = {};
for (int t = (0); t < (2); t++) {
h[t] = P[t] + hstr[t][r] -
(l ? hstr[t][l - 1] : 0) * Apow[t][r - l + 1] % P[t];
if (h[t] >= P[t]) h[t] -= P[t];
}
return pair<int, int>(h[0], h[1]);
}
int N, M, K, dp[100005][31];
char X[100005], Y[100005];
int Xhash[2][100005], Yhash[2][100005];
int main() {
cin >> N >> X >> M >> Y >> K;
init();
hashit(N, X, Xhash);
hashit(M, Y, Yhash);
for (int i = (1); i < (N + 1); i++) {
for (int k = (0); k < (K + 1); k++) {
dp[i][k] = max(dp[i][k], dp[i - 1][k]);
if (k + 1 <= K) {
int pi = i - 1, pj = dp[i - 1][k], l = 1, r = min(N - pi, M - pj);
while (l <= r) {
int m = (l + r) / 2;
pair<int, int> hX = gethash(Xhash, pi, pi + m - 1);
pair<int, int> hY = gethash(Yhash, pj, pj + m - 1);
if (hX == hY)
l = m + 1;
else
r = m - 1;
}
dp[i - 1 + r][k + 1] = max(dp[i - 1 + r][k + 1], dp[i - 1][k] + r);
}
}
for (int k = (1); k < (K + 1); k++) dp[i][k] = max(dp[i][k], dp[i][k - 1]);
}
puts(dp[N][K] == M ? "YES" : "NO");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] % 2 != 0 && a[n - 1] % 2 != 0 && n % 2 != 0) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Trie {
static const int C = 26;
struct Node {
Node* ch[C];
T val;
Node() {
val = -1;
fill(ch, ch + C, nullptr);
}
};
Node* root;
char start;
Trie(char start = 'a') : start(start) { root = new Node(); }
void update(Node* node, T v) { node->val = max(node->val, v); }
void add(Node* node, int d, const string& S, T v) {
if (S.size() == d) {
update(node, v);
} else {
int c = S[d] - start;
if (!node->ch[c]) node->ch[c] = new Node();
add(node->ch[c], d + 1, S, v);
}
}
void add(const string& S, T v) { add(root, 0, S, v); }
T get(Node* node, int d, const string& S) {
if (S.size() == d) {
return node->val;
} else {
int c = S[d] - start;
return (node->ch[c] ? get(node->ch[c], d + 1, S) : -1);
}
}
T get(const string& S) { return get(root, 0, S); }
void getall(Node* node, int d, const string& S, vector<T>& ret) {
ret[d] = node->val;
if (d < S.size()) {
int c = S[d] - start;
if (node->ch[c]) getall(node->ch[c], d + 1, S, ret);
}
}
vector<T> getall(const string& S) {
vector<T> ret(S.size() + 1, -1);
getall(root, 0, S, ret);
return ret;
}
};
vector<int> z_algorithm(const vector<int>& S) {
int N = S.size(), c = 0;
vector<int> ret(N, 0);
for (int i = 1; i < N; i++) {
if (i + ret[i - c] < c + ret[c]) {
ret[i] = ret[i - c];
} else {
int j = max(0, c + ret[c] - i);
while (i + j < N && S[j] == S[i + j]) j++;
ret[i] = j;
c = i;
}
}
ret[0] = N;
return ret;
}
vector<int> z_algorithm(const string& S) {
int N = S.size();
vector<int> s(N);
for (int i = 0; i < N; i++) s[i] = S[i];
return z_algorithm(s);
}
vector<int> z_algorithm(string& A, string& B) {
string S = A + '!' + B;
auto z = z_algorithm(S);
vector<int> ret(B.size());
for (int i = 0; i < B.size(); i++) {
ret[i] = z[i + A.size() + 1];
}
return ret;
}
int main() {
string S;
cin >> S;
int L = S.size();
int N;
cin >> N;
vector<int> M(N);
vector<vector<int>> occur(N);
vector<string> K(N);
Trie<int> trie;
const int B = 300;
for (int i = 0; i < N; i++) {
cin >> M[i] >> K[i];
int sz = K[i].size();
if (sz >= B) {
auto z = z_algorithm(K[i], S);
for (int j = 0; j < L; j++)
if (z[j] == sz) occur[i].push_back(j);
} else {
trie.add(K[i], i);
}
}
for (int i = 0; i < L; i++) {
auto t = trie.getall(S.substr(i, B - 1));
for (int j : t)
if (j != -1) occur[j].push_back(i);
}
for (int i = 0; i < N; i++) {
int sz = occur[i].size(), ans;
if (sz < M[i]) {
ans = -1;
} else {
ans = 1e9;
for (int j = M[i] - 1; j < sz; j++)
ans = min(ans, occur[i][j] - occur[i][j - M[i] + 1] + (int)K[i].size());
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long flag;
char s, s1, s2, s3, s4, s5, x, x1, x2, x3, x4, x5;
int main() {
cin >> x >> s;
cin >> x1 >> s1 >> x2 >> s2 >> x3 >> s3 >> x4 >> s4 >> x5 >> s5;
flag = 0;
if (x1 == x || x2 == x || x3 == x || x4 == x || x5 == x) flag++;
if (s1 == s || s2 == s || s3 == s || s4 == s || s5 == s) flag++;
if (flag == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> noprimes(1000001);
void seive(vector<int> &primes, int n) {
vector<bool> ntprimes(n + 1, false);
ntprimes[0] = ntprimes[1] = true;
for (int i = 2; i * i <= n; i++) {
if (!ntprimes[i]) {
for (int j = i * i; j <= n; j += i) {
ntprimes[j] = true;
}
}
}
int x = 0;
for (int i = 2; i <= n; i++) {
if (!ntprimes[i]) {
primes.push_back(i);
x++;
noprimes[i] = x;
} else
noprimes[i] = x;
}
}
long long pow(long long x, long long n) {
long long res = 1;
while (n) {
if (n % 2 == 0) {
n = n / 2;
x = x * x;
} else {
res *= x;
n--;
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
string ans;
int flag = 1;
int cnt1 = 0;
int cnt0 = 0;
int cnt2 = 0;
int index = s.size();
for (int i = 0; i < s.size(); i++) {
if (index == s.size() && s[i] == '2') {
index = i;
}
if (s[i] == '2')
cnt2++;
else if (s[i] == '1')
cnt1++;
else
cnt0++;
}
int cnt = 0;
int count = 0;
for (int i = 0; i < index; i++) {
if (s[i] == '0') {
ans = '0' + ans;
count++;
} else {
ans = ans + '1';
cnt++;
}
}
cnt1 -= cnt;
for (int i = 0; i < cnt1; i++) ans += '1';
for (int i = index; i < s.size(); i++) {
if (s[i] == '2')
ans += '2';
else if (s[i] == '0')
ans += '0';
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
char A[MAXN];
char B[MAXN];
int n;
void open() {
freopen("B.in", "r", stdin);
freopen("B.out", "w", stdout);
}
void close() {
fclose(stdin);
fclose(stdout);
}
void init() {
scanf("%s", A + 1);
scanf("%s", B + 1);
}
bool equal(int l1, int r1, int l2, int r2) {
int flag = 1;
for (int i = 0, END = r1 - l1; i <= END; i++)
if (A[i + l1] != B[i + l2]) {
flag = 0;
break;
}
if (flag)
return true;
else if ((r1 - l1 + 1) & 1)
return false;
int mid1 = (l1 + r1) / 2, mid2 = (l2 + r2) / 2;
if (equal(l1, mid1, l2, mid2)) {
if (equal(mid1 + 1, r1, mid2 + 1, r2)) return true;
}
if (equal(mid1 + 1, r1, l2, mid2)) {
if (equal(l1, mid1, mid2 + 1, r2)) return true;
}
}
int main() {
init();
int n1 = strlen(A + 1), n2 = strlen(B + 1);
if (n1 != n2) {
printf("NO\n");
} else {
if (equal(1, n1, 1, n2))
printf("YES\n");
else
printf("NO\n");
}
close();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k;
cin >> n >> k;
if (k > n) {
cout << -1 << "\n";
return 0;
}
vector<long long> vll;
for (long long temp = 0; cin >> temp;) vll.push_back(temp);
sort(vll.begin(), vll.end());
reverse(vll.begin(), vll.end());
long long temp;
int i = 0;
for (; i < k; i++) temp = vll[i];
if (i < vll.size()) {
if (temp == vll[i]) {
cout << -1 << "\n";
}
cout << temp << " " << temp << "\n";
} else
cout << temp << " " << temp << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000, L = 10;
vector<int> gsum[L];
int SG(long long x) {
if (!x) return 0;
if (x == 1) return 0;
long long l = floor(pow(x, 0.25));
while (l < 0 || l * l * l * l < x) l++;
long long r = ceil(pow(x, 0.5));
while (r * r > x) r--;
r++;
for (int n_ = (L), i = 0; i < n_; ++i)
if (r >= (int)gsum[i].size() || gsum[i][r] == gsum[i][l]) return i;
assert(false);
return 0;
}
int main(int argc, char *argv[]) {
int n;
cin >> n;
vector<long long> a(n);
for (int n_ = (n), i = 0; i < n_; ++i) cin >> a[i];
for (int n_ = (L), i = 0; i < n_; ++i) gsum[i].push_back(0);
for (int n_ = (M), i = 0; i < n_; ++i) {
int g = SG(i);
for (int n_ = (L), j = 0; j < n_; ++j) {
gsum[j].push_back(gsum[j].back());
if (j == g) gsum[j].back()++;
}
}
int ans = 0;
for (auto &ai : a) ans ^= SG(ai);
if (ans)
cout << "Furlo" << endl;
else
cout << "Rublo" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e4 + 10;
int n, m;
namespace flow {
int limt;
struct edge {
int to, cap, flow, rev, lim;
};
vector<edge> g[maxn + 10];
int s, t, ndcnt, d[maxn + 10], cur[maxn + 10];
queue<int> q;
void init(int ss, int tt, int nn) {
s = ss;
t = tt;
for (int i = 1; i <= ndcnt; ++i) g[i].clear();
ndcnt = nn;
}
void addedge(int l, int r, int w) {
g[l].push_back((edge){r, 1, 0, (int)g[r].size(), w});
g[r].push_back((edge){l, 0, 0, (int)g[l].size() - 1, w});
}
bool bfs() {
for (int i = 1; i <= ndcnt; ++i) d[i] = i == s ? 0 : -1;
q.push(s);
while (!q.empty()) {
int p = q.front();
q.pop();
for (int i = 0; i < (int)g[p].size(); ++i) {
edge e = g[p][i];
if (e.cap > e.flow && d[e.to] == -1 && e.lim <= limt) {
d[e.to] = d[p] + 1;
q.push(e.to);
}
}
}
return d[t] != -1;
}
int dfs(int p, int a) {
if (p == t) return a;
int ans = 0, now;
for (int &i = cur[p]; i < (int)g[p].size(); ++i) {
edge &e = g[p][i];
if (e.cap > e.flow && d[p] + 1 == d[e.to] && e.lim <= limt) {
now = dfs(e.to, min(a, e.cap - e.flow));
e.flow += now;
g[e.to][e.rev].flow -= now;
ans += now;
a -= now;
if (!a) break;
}
}
return ans;
}
int solve(int lim) {
int ans = 0;
limt = lim;
while (bfs()) {
for (int i = 1; i <= ndcnt; ++i) cur[i] = 0;
ans += dfs(s, 1e9);
}
return ans;
}
} // namespace flow
struct node {
int x, y, z;
} g[100010];
void grap() {
flow::init(2 * n + 1, 2 * n + 2, 2 * n + 2);
for (int i = 0; i < m; i++) {
flow::addedge(g[i].x, g[i].y + n, g[i].z);
}
for (int i = 1; i <= n; i++) {
flow::addedge(2 * n + 1, i, 1);
flow::addedge(n + i, 2 * n + 2, 1);
}
}
int main() {
cin >> n >> m;
int lim = 0;
flow::init(2 * n + 1, 2 * n + 2, 2 * n + 2);
for (int i = 0, x, y, z; i < m; i++) {
cin >> x >> y >> z;
lim = max(z, lim);
g[i] = node{x, y, z};
}
int l = 1, r = lim;
while (l < r) {
int mid = l + r >> 1;
grap();
if (flow::solve(mid) == n)
r = mid;
else
l = mid + 1;
}
if (r == lim) {
grap();
if (flow::solve(r) == n)
cout << r << endl;
else
cout << -1 << endl;
} else
cout << r << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
long w[4];
int main() {
long i, j, k, k1, k2, t, an, x, y;
char c;
scanf("%ld", &t);
for (; t; t--) {
for (i = 0; i < 4; i++) {
w[i] = 0;
}
k = 5;
an = 1;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
scanf("%c", &c);
while (c != 'K' && c != '.' && c != '#') {
scanf("%c", &c);
}
if (c != '#') {
w[(i + j) % 4] = 1;
}
if (c == 'K') {
if (k > 4) {
k = (i + j) % 4;
x = i;
y = j;
} else {
if (k != ((i + j) % 4)) {
an = 0;
}
if (!((((i - x + 64) / 2) % 2 == 0) &&
(((j - y + 64) / 2) % 2 == 0))) {
an = 0;
}
}
}
}
}
if (an && w[k]) {
printf("YES\n");
} else
printf("NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 1e9 + 7;
template <class T>
inline T read(T &x) {
int f = 1;
char ch = getchar();
x = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x *= f;
}
int T, n;
char str[N];
int sa[N], rk[N], _rk[N], cnt[N], id[N], ht[N];
int Cmp(int x, int y, int w) {
return _rk[x] == _rk[y] && _rk[x + w] == _rk[y + w];
}
void SA() {
int m = 30, p;
memset(cnt, 0, sizeof(cnt));
for (int(i) = (1); (i) <= (n); (i)++) cnt[rk[i] = str[i] - 'a' + 1]++;
for (int(i) = (1); (i) <= (m); (i)++) cnt[i] += cnt[i - 1];
for (int(i) = (n); (i) >= (1); (i)--) sa[cnt[rk[i]]--] = i;
for (int w = 1; w < n; w *= 2, m = p) {
p = 0;
for (int(i) = (n - w + 1); (i) <= (n); (i)++) id[++p] = i;
for (int(i) = (1); (i) <= (n); (i)++)
if (sa[i] > w) id[++p] = sa[i] - w;
memset(cnt, 0, sizeof(cnt));
for (int(i) = (1); (i) <= (n); (i)++) cnt[rk[id[i]]]++;
for (int(i) = (1); (i) <= (m); (i)++) cnt[i] += cnt[i - 1];
for (int(i) = (n); (i) >= (1); (i)--) sa[cnt[rk[id[i]]]--] = id[i];
p = 0;
memcpy(_rk, rk, sizeof(_rk));
for (int(i) = (1); (i) <= (n); (i)++)
rk[sa[i]] = Cmp(sa[i], sa[i - 1], w) ? p : ++p;
}
p = 0;
for (int(i) = (1); (i) <= (n); (i)++) {
if (p) p--;
while (str[i + p] == str[sa[rk[i] - 1] + p]) p++;
ht[rk[i]] = p;
}
}
struct Stack {
int h, len;
} stk[N];
int top;
long long ans, sum;
int main() {
read(T);
while (T--) {
scanf("%s\n", str + 1);
n = strlen(str + 1);
SA();
ans = 1ll * n * (n + 1) / 2;
sum = top = 0;
for (int(i) = (2); (i) <= (n); (i)++) {
Stack tmp = (Stack){ht[i], 1};
while (top && ht[i] < stk[top].h) {
sum -= 1ll * stk[top].h * stk[top].len;
tmp.len += stk[top].len;
top--;
}
stk[++top] = tmp;
sum += 1ll * tmp.h * tmp.len;
ans += sum * 2;
}
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 256;
int n, a[mx];
vector<int> odd;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
a[c]++;
}
for (int i = 0; i < mx; ++i) {
if (a[i] % 2 == 1) {
odd.push_back(i);
a[i] -= 1;
}
}
if (odd.size() == 0) {
vector<int> str;
cout << 1 << '\n';
int ptr = 0, len = n / 2;
while (len > 0) {
if (a[ptr] <= 0)
ptr++;
else {
str.push_back(ptr);
a[ptr] -= 2;
len -= 1;
}
}
for (int i = 0; i < n / 2; ++i) {
str.push_back(str[n / 2 - 1 - i]);
}
for (int i = 0; i < n; ++i) {
cout << (char)str[i];
}
cout << '\n';
return 0;
}
int even = n - odd.size(), odd_even, len;
for (int k = 0; k <= even; k += 2) {
if ((even - k) % (2 * (k + odd.size())) == 0) {
odd_even = k;
len = (even - k) / (2 * (k + odd.size()));
break;
}
}
int ptr = 0;
while (odd_even > 0) {
if (a[ptr] <= 0)
ptr++;
else {
a[ptr]--;
odd_even--;
odd.push_back(ptr);
}
}
cout << n / (2 * len + 1) << '\n';
ptr = 0;
for (int i = 0; i < odd.size(); ++i) {
vector<int> str;
int now_len = len;
while (now_len > 0) {
if (a[ptr] <= 0)
ptr++;
else {
a[ptr] -= 2;
str.push_back(ptr);
now_len -= 1;
}
}
str.push_back(odd[i]);
for (int j = 0; j < len; ++j) {
str.push_back(str[len - 1 - j]);
}
for (int j = 0; j < 2 * len + 1; ++j) {
cout << (char)str[j];
}
cout << ' ';
}
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
struct Edge {
int to, val, next;
} edge[300086];
int s, t;
int cnt = -1;
int head[300086];
queue<int> q;
int d[300086];
int cur[300086];
void addEdge(int u, int v, int w) {
cnt++;
edge[cnt].to = v;
edge[cnt].val = w;
edge[cnt].next = head[u];
head[u] = cnt;
cnt++;
edge[cnt].to = u;
edge[cnt].val = 0;
edge[cnt].next = head[v];
head[v] = cnt;
}
bool bfs() {
memset(d, -1, sizeof(d));
d[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
cur[v] = head[v];
if (d[v] == -1 && edge[i].val > 0) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
return d[t] != -1;
}
int dfs(int u, int flow) {
int nowflow = 0;
if (u == t) return flow;
for (int i = cur[u]; i != -1; i = edge[i].next) {
cur[u] = i;
int v = edge[i].to;
int w = edge[i].val;
if (d[v] == d[u] + 1 && w > 0) {
int k = dfs(v, min(flow - nowflow, w));
if (k > 0) {
edge[i].val -= k;
edge[i ^ 1].val += k;
nowflow += k;
if (nowflow == flow) break;
}
}
}
if (!nowflow) d[u] = -1;
return nowflow;
}
int dinic() {
int ans = 0;
while (bfs()) {
ans += dfs(s, inf);
}
return ans;
}
int n, m, g;
bool a[300086];
int w, x, y, z, sum;
int main() {
memset(head, -1, sizeof(head));
scanf("%d%d%d", &n, &m, &g);
s = 0, t = n + m + 1;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
scanf("%d", &x), a[i] ? addEdge(i, t, x) : addEdge(s, i, x);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &w, &y), sum += w;
while (y--) {
scanf("%d", &z);
x ? addEdge(z, i + n, inf) : addEdge(i + n, z, inf);
}
scanf("%d", &y), w += y * g;
x ? addEdge(i + n, t, w) : addEdge(s, i + n, w);
}
printf("%d", sum - dinic());
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using VB = vector<bool>;
int T;
int N;
VI a;
VVI c, aib;
void ReadData();
void Solve();
void Update(int i, int j, int val);
int Query(int i, int j);
int main() {
cin >> T;
while (T--) {
ReadData();
Solve();
}
return 0;
}
void ReadData() {
cin >> N;
a = VI(N + 1);
for (int i = 1; i <= N; ++i) cin >> a[i];
}
void Solve() {
c = VVI(N + 1, VI(N + 1));
for (int i = 1; i <= N; ++i)
for (int j = i + 1; j <= N; ++j)
if (a[i] == a[j]) c[i][j] = 1;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) c[i][j] += c[i - 1][j];
aib = VVI(N + 1, VI(N + 1));
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j)
if (c[i][j]) Update(i, j, c[i][j]);
long long ans{0};
for (int i = 1; i <= N; ++i)
for (int j = i + 1; j <= N; ++j)
if (a[i] == a[j]) {
int p1 = i + 1;
int p2 = j - 1;
int v = j + 1;
int t1 = Query(p2, N) - Query(p2, v - 1);
int t2 = Query(p1 - 1, N) - Query(p1 - 1, v - 1);
ans += t1 - t2;
}
cout << ans << '\n';
}
void Update(int i, int j, int val) {
for (int p = j; p <= N; p += p & -p) aib[i][p] += val;
}
int Query(int i, int j) {
int ans{0};
for (int p = j; p > 0; p -= p & -p) ans += aib[i][p];
return ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e5;
const long long mod = 1e9 + 7;
int main() {
int n, m, d;
cin >> n >> m >> d;
vector<int> a(m);
vector<int> ans(n, 0);
for (int i = 0; i < m; i++) cin >> a[i];
int ind = m, t = a[m - 1], last = 0;
for (int i = n - 1; i >= 0; i--) {
if (t > 0) {
ans[i] = ind;
t--;
} else {
ind--;
if (ind == 0) {
last = i + 1;
break;
}
t = a[ind - 1];
ans[i] = ind;
t--;
}
}
int curr = 1;
bool p = 0;
for (int i = d - 1; i < n; i += d) {
if (ans[i] == 0) {
if (curr > m) {
cout << "NO\n";
p = 1;
break;
}
int j;
for (j = last; j < last + a[curr - 1]; j++) ans[j] = 0;
for (j = i; j < i + a[curr - 1]; j++) ans[j] = curr;
i = j - 1;
last += a[curr - 1];
curr++;
}
}
if (!p) {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF(0x3f3f3f3f3f3f3f3fll);
const long long inf(0x3f3f3f3f);
template <typename T>
void read(T &res) {
bool flag = false;
char ch;
while (!isdigit(ch = getchar())) (ch == '-') && (flag = true);
for (res = ch - 48; isdigit(ch = getchar());
res = (res << 1) + (res << 3) + ch - 48)
;
flag && (res = -res);
}
template <typename T>
void Out(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) Out(x / 10);
putchar(x % 10 + '0');
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long pow_mod(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long fact_pow(long long n, long long p) {
long long res = 0;
while (n) {
n /= p;
res += n;
}
return res;
}
long long mult(long long a, long long b, long long p) {
a %= p;
b %= p;
long long r = 0, v = a;
while (b) {
if (b & 1) {
r += v;
if (r > p) r -= p;
}
v <<= 1;
if (v > p) v -= p;
b >>= 1;
}
return r;
}
long long quick_pow(long long a, long long b, long long p) {
long long r = 1, v = a % p;
while (b) {
if (b & 1) r = mult(r, v, p);
v = mult(v, v, p);
b >>= 1;
}
return r;
}
bool CH(long long a, long long n, long long x, long long t) {
long long r = quick_pow(a, x, n);
long long z = r;
for (long long i = 1; i <= t; i++) {
r = mult(r, r, n);
if (r == 1 && z != 1 && z != n - 1) return true;
z = r;
}
return r != 1;
}
bool Miller_Rabin(long long n) {
if (n < 2) return false;
if (n == 2) return true;
if (!(n & 1)) return false;
long long x = n - 1, t = 0;
while (!(x & 1)) {
x >>= 1;
t++;
}
srand(time(NULL));
long long o = 8;
for (long long i = 0; i < o; i++) {
long long a = rand() % (n - 1) + 1;
if (CH(a, n, x, t)) return false;
}
return true;
}
long long prime[100000], minprime[100000];
void euler(long long n) {
long long c = 0, i, j;
for (i = 2; i <= n; i++) {
if (!minprime[i]) prime[++c] = i, minprime[i] = i;
for (j = 1; j <= c && i * prime[j] <= n; j++) {
minprime[i * prime[j]] = prime[j];
if (i % prime[j] == 0) break;
}
}
}
struct Tree {
long long l, r, sum, lazy, maxn, minn;
} tree[100000];
inline void push_up(long long rt) {
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
tree[rt].maxn = max(tree[rt << 1].maxn, tree[rt << 1 | 1].maxn);
tree[rt].minn = min(tree[rt << 1].minn, tree[rt << 1 | 1].minn);
}
inline void push_down(long long rt, long long length) {
if (tree[rt].lazy) {
tree[rt << 1].lazy += tree[rt].lazy;
tree[rt << 1 | 1].lazy += tree[rt].lazy;
tree[rt << 1].sum += (length - (length >> 1)) * tree[rt].lazy;
tree[rt << 1 | 1].sum += (length >> 1) * tree[rt].lazy;
tree[rt << 1].minn += tree[rt].lazy;
tree[rt << 1 | 1].minn += tree[rt].lazy;
tree[rt << 1].maxn += tree[rt].lazy;
tree[rt << 1 | 1].maxn += tree[rt].lazy;
tree[rt].lazy = 0;
}
}
inline void build(long long l, long long r, long long rt, long long *aa) {
tree[rt].lazy = 0;
tree[rt].l = l;
tree[rt].r = r;
if (l == r) {
tree[rt].sum = aa[l];
tree[rt].minn = tree[rt].sum;
tree[rt].maxn = tree[rt].sum;
return;
}
long long mid = (l + r) >> 1;
build(l, mid, rt << 1, aa);
build(mid + 1, r, rt << 1 | 1, aa);
push_up(rt);
}
inline void update_range(long long L, long long R, long long key,
long long rt) {
if (tree[rt].r < L || tree[rt].l > R) return;
if (L <= tree[rt].l && R >= tree[rt].r) {
tree[rt].sum += (tree[rt].r - tree[rt].l + 1) * key;
tree[rt].minn += key;
tree[rt].maxn += key;
tree[rt].lazy += key;
return;
}
push_down(rt, tree[rt].r - tree[rt].l + 1);
long long mid = (tree[rt].r + tree[rt].l) >> 1;
if (L <= mid) update_range(L, R, key, rt << 1);
if (R > mid) update_range(L, R, key, rt << 1 | 1);
push_up(rt);
}
inline long long query_range(long long L, long long R, long long rt) {
if (L <= tree[rt].l && R >= tree[rt].r) {
return tree[rt].sum;
}
push_down(rt, tree[rt].r - tree[rt].l + 1);
long long mid = (tree[rt].r + tree[rt].l) >> 1;
long long ans = 0;
if (L <= mid) ans += query_range(L, R, rt << 1);
if (R > mid) ans += query_range(L, R, rt << 1 | 1);
return ans;
}
inline long long query_min(long long L, long long R, long long rt) {
if (L <= tree[rt].l && R >= tree[rt].r) {
return tree[rt].minn;
}
push_down(rt, tree[rt].r - tree[rt].l + 1);
long long mid = (tree[rt].r + tree[rt].l) >> 1;
long long ans = (0x3f3f3f3f3f3f3f3fll);
if (L <= mid) ans = min(ans, query_min(L, R, rt << 1));
if (R > mid) ans = min(ans, query_min(L, R, rt << 1 | 1));
return ans;
}
inline long long query_max(long long L, long long R, long long rt) {
if (L <= tree[rt].l && R >= tree[rt].r) {
return tree[rt].maxn;
}
push_down(rt, tree[rt].r - tree[rt].l + 1);
long long mid = (tree[rt].r + tree[rt].l) >> 1;
long long ans = -(0x3f3f3f3f3f3f3f3fll);
if (L <= mid) ans = max(ans, query_max(L, R, rt << 1));
if (R > mid) ans = max(ans, query_max(L, R, rt << 1 | 1));
return ans;
}
const long long N = 3e5 + 10;
long long n, a[N], cnt[N];
signed main() {
std::ios::sync_with_stdio(false);
long long n, B;
cin >> n >> B;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long sum = 0, now = 0;
for (long long i = 1; i <= n; i++) {
if (a[i] & 1)
sum++;
else
sum--;
if (sum == 0 && i + 1 <= n) cnt[++now] = abs(a[i + 1] - a[i]);
}
sort(cnt + 1, cnt + 1 + now);
long long ans = 0;
for (long long i = 1; i <= now; i++) {
if (B >= cnt[i])
B -= cnt[i], ans++;
else
break;
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using VI = vector<int>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
ll a, b, c, d, ans;
cin >> a >> b >> c >> d;
if (a > b * c) {
ans = -1;
} else {
ll k = a / (b * d);
ans = a * (k + 1) - b * d * (k * (k + 1)) / 2;
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
int n, sum = 0, store = 0;
cin >> n;
for (int i = (0); i <= (n - 1); ++i) {
int a, b;
cin >> a >> b;
sum += b - a;
store = max(store, sum);
}
cout << store;
}
| 0 |
#include <iostream>
#include <unordered_map>
#include <map>
using namespace std;
map<int, map<int, int>> queries;
void updateAnswer(int answer) {
for (auto i = queries.begin(); i != queries.upper_bound(answer); i++) {
for (auto j = i->second.lower_bound(answer); j != i->second.end(); j++) {
j->second++;
}
}
}
int query(int lb, int ub) {
if (queries.find(lb) != queries.end() && queries[lb].find(ub) != queries[lb].end()) return queries[lb][ub];
cout << "? " << lb << " " << ub << endl;
cout.flush();
int sum;
cin >> sum;
queries[lb][ub] = sum;
return sum;
}
void solve(int n) {
int k;
cin >> k;
int lb = 1, ub = n;
int zeros;
int sum = query(1, ub);
zeros = n - sum;
while (ub - lb >= 1) {
int i = (ub + lb) / 2;
int sum = query(1, i);
int targetSum = i;
zeros = targetSum - sum;
if (zeros < k) lb = i + 1;
else ub = i;
}
cout << "! " << lb << endl;
updateAnswer(lb);
}
int main() {
int n, t;
cin >> n >> t;
while (t--) solve(n);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll maxn = 1e5 + 10;
void debug() { ; }
template <typename Head, typename... Tail>
void debug(Head H, Tail... T) {
cerr << H << " ";
debug(T...);
}
ll pref1[100005], pref2[100005];
void solve() {
ll n, m, k;
cin >> n >> m >> k;
bool a[n], b[m];
vector<ll> suba, subb;
ll size = 0;
for (ll i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] == 1)
size++;
else if (size > 0) {
suba.emplace_back(size);
size = 0;
}
}
if (size > 0) {
suba.emplace_back(size);
size = 0;
}
for (ll i = 0; i < m; ++i) {
cin >> b[i];
if (b[i] == 1)
size++;
else if (size > 0) {
subb.emplace_back(size);
size = 0;
}
}
if (size > 0) {
subb.emplace_back(size);
size = 0;
}
if (suba.size() == 0 or subb.size() == 0) {
cout << "0";
return;
}
sort(suba.begin(), suba.end());
sort(subb.begin(), subb.end());
for (ll i = suba.size() - 1; i >= 0; --i) {
if (i == suba.size() - 1)
pref1[i] = suba[i];
else
pref1[i] = suba[i] + pref1[i + 1];
}
for (ll i = subb.size() - 1; i >= 0; --i) {
if (i == subb.size() - 1)
pref2[i] = subb[i];
else
pref2[i] = subb[i] + pref2[i + 1];
}
ll ans{};
for (int i = 1; i <= sqrt(k); i++) {
if (k % i == 0) {
ll x = i;
ll y = k / i;
ll rightover1 = lower_bound(suba.begin(), suba.end(), x) - suba.begin();
ll rightover2 = lower_bound(subb.begin(), subb.end(), y) - subb.begin();
if (rightover1 < suba.size() and rightover2 < subb.size()) {
ans += (pref1[rightover1] - (suba.size() - rightover1) * (x - 1)) *
(pref2[rightover2] - (subb.size() - rightover2) * (y - 1));
}
if (x != y) {
swap(x, y);
ll rightover1 = lower_bound(suba.begin(), suba.end(), x) - suba.begin();
ll rightover2 = lower_bound(subb.begin(), subb.end(), y) - subb.begin();
if (rightover1 < suba.size() and rightover2 < subb.size()) {
ans += (pref1[rightover1] - (suba.size() - rightover1) * (x - 1)) *
(pref2[rightover2] - (subb.size() - rightover2) * (y - 1));
}
}
}
}
cout << ans;
return;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll t;
t = 1;
for (ll i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 + 5000;
const int INF = 1000000000;
int memo[MAXN][MAXN / 2][2];
bool done[MAXN][MAXN / 2][2];
int arr[MAXN];
int N;
int get(int le, int hi) {
if (le < hi) return 0;
return 1 + le - hi;
}
int dp(int i, int l, bool f) {
if (l == 0) return 0;
if (i >= N) return INF;
int& ans = memo[i][l][f];
if (!done[i][l][f]) {
done[i][l][f] = true;
ans = dp(1 + i, l, false);
int costbef = 0;
if (i - 1 >= 0) {
costbef = get(arr[i - 1], arr[i]);
}
int cost = f ? 0 : costbef, cost2 = f ? 0 : costbef;
if (1 + i < N) {
cost += get(arr[1 + i], arr[i]);
}
if (2 + i < N) {
cost2 += get(arr[1 + i], min(arr[i], arr[2 + i]));
ans = min(ans, cost2 + dp(i + 2, l - 1, true));
}
ans = min(ans, cost + dp(i + 2, l - 1, false));
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = (int)0; i < (int)N; ++i) cin >> arr[i];
int tec = (N >> 1) + ((N % 2) != 0);
for (int i = 1; i <= tec; ++i) {
cout << dp(0, i, true) << ' ';
}
return 0;
}
| 5 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int n,a[510],x0;
bool sp[510];
void solve() {
cin >> n >> x0;
vector<int> sps;
for (int i = 1; i <= n; i++) cin >> a[i], sp[i] = false;
for (int i = 2; i <= n; i++) {
int t = 0;
for (int j = 1; j < i; j++) if (a[j] > a[i])t++;
if (t > 1) { cout << -1 << endl; return; }
}
int res = 0;
for (int i = 1; i < n; i++) {
if (a[i] > a[i + 1]) sp[i] = true,res++, sps.push_back(i);
}
int x = x0;
if (res == 0) { cout << 0 << endl; return; }
if (x > a[sps[0] + 1]) {
cout << -1 << endl; return;
}
int st = 1;
for (int i = 0; i < sps.size(); i++) {
for (int j = st; j < sps[i]; j++) {
if (a[j] > x) {
int temp = a[j];
a[j] = x; x = temp;
res++;
}
}
int temp = a[sps[i]];
a[sps[i]] = x; x = temp;
st = sps[i] + 1;
}
cout << res << endl;
}
int main()
{
int t; cin >> t;
while (t--) solve();
// system("pause");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct node {
int to, nxt;
} edge[N << 1];
int n, num, head[N], ans[N], res, f[N];
inline int read() {
int x = 0, w = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') c = getchar(), w = -1;
while (isdigit(c)) {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * w;
}
inline void add_edge(int from, int to) {
edge[++num] = (node){to, head[from]};
head[from] = num;
}
void dfs(int k, int fa, int x) {
int fir = 0, sec = 0;
for (register int i = head[k]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == fa) continue;
dfs(v, k, x);
if (f[v] > fir)
sec = fir, fir = f[v];
else
sec = max(sec, f[v]);
}
if (fir + sec + 1 >= x)
f[k] = 0, ++res;
else
f[k] = fir + 1;
}
void solve(int s, int t, int l, int r) {
if (s > t || l > r) return;
if (l == r) {
for (register int i = s; i <= t; i++) ans[i] = l;
return;
}
int mid = (s + t) >> 1;
res = 0;
dfs(1, 0, mid);
ans[mid] = res;
solve(s, mid - 1, res, r);
solve(mid + 1, t, l, res);
}
int main() {
n = read();
for (register int i = 1; i < n; i++) {
int x = read(), y = read();
add_edge(x, y);
add_edge(y, x);
}
solve(1, n, 0, n);
for (register int i = 1; i <= n; i++) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
if (x > 0 && y > 0) cout << "0 " << x + y << " " << x + y << " 0";
if (x < 0 && y > 0) cout << x - y << " 0 0 " << y - x;
if (x > 0 && y < 0) cout << "0 " << y - x << " " << x - y << " 0";
if (x < 0 && y < 0) cout << x + y << " 0 0 " << x + y;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct cell {
long long int ls;
long long int x1, y1, x2, y2;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, t;
t = 1;
while (t--) {
long long int n, m;
cin >> n >> m;
string s1, s2;
cin >> s1 >> s2;
long long int dp[n + 5][m + 5];
for (i = 0; i <= n + 1; i++) {
for (j = 0; j <= m; j++) dp[i][j] = 0;
}
long long int ans = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
dp[i][j] = max(dp[i - 1][j] - 1, dp[i][j - 1] - 1);
if (s1[i - 1] == s2[j - 1]) {
dp[i][j] = max(dp[i - 1][j - 1] + 2, dp[i][j]);
dp[i][j] = max(dp[i][j], (long long int)2);
}
ans = max(ans, dp[i][j]);
}
}
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v(5010);
long long solve(int l, int r) {
if (l > r) return 0;
if (l == r) {
return min((long long)1, v[l]);
}
long long m1 = 1000 * 1000 * 1000 + 2;
vector<int> temp;
temp.push_back(l - 1);
for (int i = l; i <= r; ++i) m1 = min(v[i], m1);
for (int i = l; i <= r; ++i) {
if (v[i] == m1) temp.push_back(i);
}
temp.push_back(r + 1);
long long ans = m1;
for (int i = l; i <= r; ++i) v[i] -= m1;
for (int i = 0; i < temp.size() - 1; ++i)
ans += solve(temp[i] + 1, temp[i + 1] - 1);
return min(ans, (long long)(r - l + 1));
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> v[i];
cout << solve(1, n);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, dp[2100000][2], ans;
int main() {
cin >> t;
for (int i = 3; i < 2000000 + 1; i++) {
dp[i][1] = dp[i - 1][0] + 2 * dp[i - 2][0] + 1;
dp[i][0] =
max(dp[i - 1][0], dp[i - 1][1]) + 2 * max(dp[i - 2][0], dp[i - 2][1]);
dp[i][1] = (dp[i][1] % 1000000007 + 1000000007) % 1000000007;
dp[i][0] = (dp[i][0] % 1000000007 + 1000000007) % 1000000007;
}
while (t--) {
cin >> n;
cout << (4 * max(dp[n][1], dp[n][0]) % 1000000007 + 1000000007) % 1000000007
<< "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, s;
scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
s = a + b + c + d + e;
if (s / 5 == 0)
printf("-1\n");
else {
if (s % 5 == 0)
printf("%d\n", s / 5);
else
printf("-1\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const int S = 52;
const int P = 1e9 + 7;
char str[N + 3];
int a[N + 3];
int num[S + 3];
long long dp1[S + 3][N + 3], dp2[S + 3][N + 3], g[N + 3];
long long fact[N + 3], finv[N + 3];
long long ans[S + 3][S + 3];
int n, q;
long long quickpow(long long x, long long y) {
long long cur = x, ret = 1ll;
for (int i = 0; y; i++) {
if (y & (1ll << i)) {
y -= (1ll << i);
ret = ret * cur % P;
}
cur = cur * cur % P;
}
return ret;
}
long long mulinv(long long x) { return finv[x] * fact[x - 1] % P; }
long long comb(long long x, long long y) {
return x < 0 || y < 0 || x < y ? 0ll
: fact[x] * finv[y] % P * finv[x - y] % P;
}
long long combinv(long long x, long long y) {
return x < 0 || y < 0 || x < y ? 0ll
: finv[x] * finv[y] % P * fact[x - y] % P;
}
int decode(char ch) {
if (ch >= 'A' && ch <= 'Z') {
return ch - 'A' + 27;
} else if (ch >= 'a' && ch <= 'z') {
return ch - 'a' + 1;
}
}
int main() {
fact[0] = 1ll;
for (int i = 1; i <= N; i++) fact[i] = fact[i - 1] * i % P;
finv[N] = quickpow(fact[N], P - 2);
for (int i = N - 1; i >= 0; i--) finv[i] = finv[i + 1] * (i + 1) % P;
scanf("%s", str + 1);
n = strlen(str + 1);
scanf("%d", &q);
for (int i = 1; i <= n; i++) a[i] = decode(str[i]);
for (int i = 1; i <= n; i++) num[a[i]]++;
int sum = 0;
dp1[0][0] = 1ll;
long long tot = fact[n >> 1] * fact[n >> 1] % P;
for (int i = 1; i <= S; i++) tot = tot * finv[num[i]] % P;
for (int j = 1; j <= S; j++) {
int anow = num[j];
if (anow == 0) {
for (int k = 0; k <= n; k++) dp1[j][k] = dp1[j - 1][k];
continue;
}
for (int k = 0; k <= n; k++) {
dp1[j][k] = dp1[j - 1][k];
if (k >= num[j]) {
dp1[j][k] = (dp1[j][k] + dp1[j - 1][k - num[j]]) % P;
}
}
sum += anow;
}
for (int i = 1; i <= S; i++) ans[i][i] = dp1[S][n >> 1];
for (int i = 1; i <= S; i++) {
for (int j = i + 1; j <= S; j++) {
ans[i][j] = 0ll;
int anow = num[i] + num[j];
if (anow > (n >> 1)) {
ans[i][j] = 0ll;
continue;
}
if (num[i] == 0 || num[j] == 0) {
ans[i][j] = ans[i][i];
continue;
}
for (int k = 0; k <= n; k++) {
g[k] = dp1[S][k];
}
for (int k = 0; k <= n; k++) {
g[k] = (g[k] - (k < num[i] ? 0ll : g[k - num[i]]) + P) % P;
}
for (int k = 0; k <= n; k++) {
g[k] = (g[k] - (k < num[j] ? 0ll : g[k - num[j]]) + P) % P;
}
ans[i][j] = (g[(n >> 1) - num[i] - num[j]] + g[(n >> 1)]) % P;
}
}
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
x = a[x];
y = a[y];
if (x > y) swap(x, y);
printf("%I64d\n", ans[x][y] * tot % P);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const long long inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const double eps = 1e-6;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
long long f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
template <typename T, typename... Args>
void read(T &first, Args &...args) {
read(first);
read(args...);
}
using namespace std;
const long long maxm = 1e6 + 10;
const long long maxn = 1e4 + 10;
struct EDGE {
long long next, to, w, c;
} edge[maxm << 1];
long long head[maxn], tot;
long long cur[maxn];
long long n, m;
inline void addedge(long long u, long long v, long long w, long long c) {
edge[tot] = {head[u], v, w, c};
head[u] = tot++;
edge[tot] = {head[v], u, 0, -c};
head[v] = tot++;
}
bool vis[maxn];
long long dis[maxn], flow[maxn], pre[maxn], last[maxn];
bool spfa(long long s, long long t) {
queue<long long> q;
memset(dis, 0x3f, sizeof dis);
memset(flow, 0x3f, sizeof flow);
memset(vis, 0, sizeof vis);
q.push(s);
vis[s] = 1;
dis[s] = 0;
pre[t] = -1;
while (!q.empty()) {
long long u = q.front();
q.pop();
vis[u] = 0;
for (long long i = head[u]; ~i; i = edge[i].next) {
long long v = edge[i].to;
if (edge[i].w > 0 && dis[v] > dis[u] + edge[i].c) {
dis[v] = dis[u] + edge[i].c;
pre[v] = u;
last[v] = i;
flow[v] = min(flow[u], edge[i].w);
if (!vis[v]) {
q.push(v);
vis[v] = 1;
}
}
}
}
return pre[t] != -1;
}
long long maxflow, maxcost;
void mcmf(long long s, long long t) {
maxflow = 0, maxcost = 0;
while (spfa(s, t)) {
long long u = t;
maxflow += flow[t];
maxcost += flow[t] * dis[t];
while (u != s) {
edge[last[u]].w -= flow[t];
edge[last[u] ^ 1].w += flow[t];
u = pre[u];
}
}
}
struct node {
long long s, t, c, i;
} q[maxn];
long long ans[maxn];
signed main() {
memset(head, -1, sizeof head);
long long n, k;
read(n, k);
long long s = 0, t = 2 * n + 1;
for (long long i = 1; i <= n; ++i) {
read(q[i].s, q[i].t, q[i].c);
q[i].i = i;
ans[i] = tot;
addedge(i, i + n, 1, -q[i].c);
}
sort(q + 1, q + 1 + n,
[&](const node &a, const node &b) { return a.s < b.s; });
for (long long i = 1; i <= n; ++i) {
if (i < n) addedge(q[i].i, q[i + 1].i, inf, 0);
for (long long j = i + 1; j <= n; ++j) {
if (q[i].s + q[i].t - 1 < q[j].s) {
addedge(q[i].i + n, q[j].i, inf, 0);
break;
}
}
}
addedge(s, q[1].i, k, 0);
for (long long i = 1; i <= n; ++i) {
addedge(q[i].i + n, t, inf, 0);
}
mcmf(s, t);
for (long long i = 1; i <= n; ++i) {
printf("%d ", edge[ans[i]].w == 0);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[200000], b[200000];
int main() {
int n, k;
cin >> n >> k;
n++;
for (int i = 0; i < n; i++) cin >> a[i];
int up = 0;
long long prefix_sum = 0;
for (int i = 0; i < n; i++) {
prefix_sum += a[i];
b[i] = prefix_sum;
if (prefix_sum % 2 != 0) break;
prefix_sum /= 2;
up++;
}
int ways = 0;
long long suffix_sum = 0;
for (int i = n - 1; i >= 0; i--) {
if (i <= up) {
long long total_sum = 2 * suffix_sum + b[i];
long long delta = total_sum - a[i];
if (-k <= delta && delta <= k && (i != n - 1 || delta != 0)) ways++;
}
suffix_sum = 2 * suffix_sum + a[i];
if (suffix_sum > k || suffix_sum < -k) break;
}
cout << ways;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
string arr[5];
string tmp[5];
bool check(int i, int j) {
if (j < 3 && tmp[i][j] == 'x' && tmp[i][j + 1] == 'x' && tmp[i][j + 2] == 'x')
return true;
if (i < 3 && tmp[i][j] == 'x' && tmp[i + 1][j] == 'x' && tmp[i + 2][j] == 'x')
return true;
if (i < 3 && j < 3 && tmp[i][j] == 'x' && tmp[i + 1][j + 1] == 'x' &&
tmp[i + 2][j + 2] == 'x')
return true;
if (i >= 2 && j < 3 && tmp[i][j] == 'x' && tmp[i - 1][j + 1] == 'x' &&
tmp[i - 2][j + 2] == 'x')
return true;
return false;
}
bool valid(int a, int b) {
for (int i = 0; i < 5; i++) tmp[i] = arr[i];
if (tmp[a][b] != '.') return false;
tmp[a][b] = 'x';
bool ans = false;
for (int i = 0; i < 5; i++)
for (int j = 0; j < 5; j++) ans |= check(i, j);
return ans;
}
int main() {
for (int i = 0; i < 5; i++) cin >> arr[i];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (valid(i, j)) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[100001];
long long int forard[100001] = {0};
long long int backward[100001] = {0};
bool visited[100001] = {0};
long long int paren[100001] = {0};
long long int val[100001] = {};
long long int siz[100001] = {};
long long int tmp[100001] = {};
long long int numPaths = 0;
class disjointSet {
public:
long long int anc[100001];
disjointSet(long long int n) {
for (long long int i = 0; i < n + 1; i++) anc[i] = i;
}
long long int find(const int &x) {
return x == anc[x] ? x : anc[x] = find(anc[x]);
}
void merge(const long long int &x, const long long int &y) {
anc[find(x)] = find(y);
}
bool same(const long long int &x, const long long int &y) {
return find(x) == find(y);
}
};
void DFS(long long int v, long long int parent, long long int n) {
visited[v] = 1;
paren[v] = parent;
if (parent != -1) {
forard[v] += forard[parent] + 1;
}
for (long long int child : adj[v]) {
if (child != parent) {
DFS(child, v, n);
backward[v] += backward[child];
}
}
long long int temp = numPaths;
siz[v] = 1;
for (long long int child : adj[v]) {
if (!visited[child]) {
numPaths += (backward[v] - backward[child]) * (backward[child]);
}
}
numPaths += 2 * (backward[v]) * (n - backward[v] - forard[v]);
numPaths += 2 * (backward[v]) * (forard[v] > 0 ? forard[v] - 1 : forard[v]);
visited[v] = 0;
val[v] = numPaths - temp;
backward[v]++;
}
long long int calculate(const long long int &x, long long int n) {
long long int ans = 0;
ans += 1ll * siz[x] * (siz[x] - 1) * (siz[x] - 2);
ans += 2ll * siz[x] * (siz[x] - 1) * (n - siz[x]);
ans += 1ll * (n - siz[x]) * (n - siz[x]) * siz[x];
ans -= tmp[x] * siz[x];
return val[x] = ans;
}
int main() {
for (long long int i = 0; i < 100001; i++) {
siz[i] = 1;
}
long long int n;
cin >> n;
disjointSet dj(n);
adj[0].push_back(1);
adj[1].push_back(0);
for (long long int i = 0; i < n - 1; i++) {
long long int a, b;
cin >> a;
cin >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
DFS(0, -1, n);
for (int v = 1; v < n + 1; v++) {
for (long long int y : adj[v]) {
if (dj.same(v, y)) continue;
const long long int z = dj.find(y);
const long long int sz = y == paren[v] ? n - backward[v] : backward[z];
tmp[v] += 1ll * sz * sz;
}
}
cout << numPaths << endl;
long long int m;
cin >> m;
while (m--) {
long long int a, b;
cin >> a >> b;
a = dj.find(a);
b = dj.find(b);
while (a != b) {
if (forard[a] < forard[b]) swap(a, b);
const long long int w = dj.find(paren[a]);
tmp[w] -= backward[a] * backward[a];
tmp[w] += tmp[a] - (n - backward[a]) * (n - backward[a]);
numPaths -= val[a];
siz[w] += siz[a];
dj.merge(a, w);
a = w;
}
numPaths -= val[a];
numPaths += calculate(a, n);
cout << numPaths << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 0;
int m, n, k, x, t;
string s;
vector<int> v;
int main() {
cin >> n >> m >> k;
for (int i = 0; i <= m; i++) {
cin >> x;
v.push_back(x);
}
int ans = 0;
for (int i = 0; i < m; i++) {
if (__builtin_popcount(v[i] ^ v[m]) <= k) {
ans++;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int tree[400005], N;
long long d[200005], M;
inline void add(int k) {
int bound = N * 2 + 2;
while (k <= bound) {
++tree[k];
k += k & (-k);
}
}
inline int get(int k) {
int res = 0;
while (k > 0) res += tree[k], k -= k & (-k);
return res;
}
long long solve(long long m) {
memset(tree, 0, sizeof(tree));
int cnt = 0;
long long res = 0;
add(N + 1);
for (int i = 0; i < N; ++i) {
if (d[i] >= m) cnt += 2;
add(N + cnt - i);
res += get(N + cnt - i - 1);
}
return res;
}
int main() {
scanf("%d%lld", &N, &M);
for (int i = 0; i < N; ++i) scanf("%lld", d + i);
printf("%lld\n", solve(M) - solve(M + 1));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int l, r, u, d;
int n;
int sx, sy, x, y;
int main() {
cin >> n >> sx >> sy;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
if (x < sx) l++;
if (x > sx) r++;
if (y > sy) u++;
if (y < sy) d++;
}
if (l >= r && l >= u && l >= d) {
cout << l << endl;
cout << sx - 1 << " " << sy << endl;
return 0;
} else if (r >= l && r >= u && r >= d) {
cout << r << endl;
cout << sx + 1 << " " << sy << endl;
return 0;
} else if (u >= r && u >= l && u >= d) {
cout << u << endl;
cout << sx << " " << sy + 1 << endl;
return 0;
} else if (d >= r && d >= u && d >= l) {
cout << d << endl;
cout << sx << " " << sy - 1 << endl;
return 0;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool good;
int charList[26];
string s1, s2, s3;
while (cin >> s1 >> s2 >> s3) {
good = true;
for (int i = 0; i < 26; i++) charList[i] = 0;
for (int i = 0; i < s1.length(); i++) charList[s1[i] - 'A']++;
for (int i = 0; i < s2.length(); i++) charList[s2[i] - 'A']++;
for (int i = 0; i < s3.length(); i++) charList[s3[i] - 'A']--;
for (int i = 0; i < 26; i++)
if (charList[i] != 0) good = false;
cout << (good ? "YES" : "NO") << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
const int P[2] = {(int)1e9 + 7, 985661441};
vector<pair<int, int> > v[N];
int n, x, y, sz[N], L[N], R[N], tot;
pair<int, int> f[N];
char s[5];
int ans[N];
map<pair<int, int>, int> M;
void dfs(int x) {
sz[x] = 1;
L[x] = ++tot;
for (int i = 0; i < v[x].size(); i++) {
dfs(v[x][i].first);
sz[x] += sz[v[x][i].first];
}
R[x] = tot;
}
inline pair<int, int> cal(pair<int, int> a, int b) {
return make_pair((1ll * a.first * 26 + b) % P[0],
(1ll * a.second * 26 + b) % P[1]);
}
int cnt;
void dfs3(int x, pair<int, int> s, int d) {
M[s] += d;
if (d == 1 && M[s] > 1) cnt++;
for (int i = 0; i < v[x].size(); i++)
dfs3(v[x][i].first, cal(s, v[x][i].second), d);
}
void dfs2(int x, int dep, pair<int, int> s) {
int t;
pair<int, int> son = make_pair(-1, 0);
f[L[x]] = s;
for (int i = 0; i < v[x].size(); i++)
if (son.first == -1 || sz[v[x][i].first] > sz[son.first]) son = v[x][i];
for (int i = 0; i < v[x].size(); i++)
if ((t = v[x][i].first) != son.first) {
dfs2(t, dep + 1, cal(s, v[x][i].second));
M.clear();
}
if (son.first != -1) dfs2(son.first, dep + 1, cal(s, son.second));
M[s]++;
cnt = 0;
for (int i = 0; i < v[x].size(); i++)
if ((t = v[x][i].first) != son.first) dfs3(t, cal(s, son.second), 1);
ans[dep] += cnt + (v[x].size() > 0);
for (int i = 0; i < v[x].size(); i++)
if ((t = v[x][i].first) != son.first) {
dfs3(t, cal(s, son.second), -1);
for (int j = L[t]; j <= R[t]; j++) M[f[j]]++;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%s", &x, &y, &s);
v[x].push_back(make_pair(y, s[0] - 'a'));
}
dfs(1);
dfs2(1, 1, make_pair(0, 0));
int ans1 = 1;
for (int i = 2; i < N; i++)
if (ans[i] > ans[ans1]) ans1 = i;
printf("%d\n", n - ans[ans1]);
printf("%d\n", ans1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int w, x, y, z;
bool operator<(data b) const {
if (w < b.w) return 1;
if (w > b.w) return 0;
if (x < b.x) return 1;
if (x > b.x) return 0;
if (y < b.y) return 1;
if (y > b.y) return 0;
if (z < b.z) return 1;
return 0;
}
data add(int s) const {
if (s == 0) return (data){w + 1, x, y, z};
if (s == 1) return (data){w, x + 1, y, z};
if (s == 2) return (data){w, x, y + 1, z};
if (s == 3) return (data){w, x, y, z + 1};
}
int get(int s) const {
if (s == 0) return w;
if (s == 1) return x;
if (s == 2) return y;
if (s == 3) return z;
}
};
set<data> H[10004];
bool p[4];
int main() {
int n, tmp, d[4] = {0, 0, 0, 0}, e[4], i, j;
char s[10004];
set<data>::iterator it;
scanf("%d%s", &n, s);
H[0].insert((data){0, 0, 0, 0});
for (i = 0; i < n; i++) {
if (s[i] == 'G')
tmp = 0;
else if (s[i] == 'H')
tmp = 1;
else if (s[i] == 'R')
tmp = 2;
else if (s[i] == 'S')
tmp = 3;
else
tmp = 4;
if (tmp < 4) {
d[tmp]++;
H[i + 1] = H[i];
} else {
for (it = H[i].begin(); it != H[i].end(); it++) {
for (j = 0; j < 4; j++) e[j] = d[j] + it->get(j);
int small = 100000;
for (j = 0; j < 4; j++)
if (e[j] < small) small = e[j];
for (j = 0; j < 4; j++)
if (e[j] == small) H[i + 1].insert(it->add(j));
}
}
}
for (it = H[n].begin(); it != H[n].end(); it++) {
for (i = 0; i < 4; i++) e[i] = d[i] + it->get(i);
int small = 100000;
for (j = 0; j < 4; j++)
if (e[j] < small) small = e[j];
for (j = 0; j < 4; j++)
if (e[j] == small) p[j] = 1;
}
if (p[0]) puts("Gryffindor");
if (p[1]) puts("Hufflepuff");
if (p[2]) puts("Ravenclaw");
if (p[3]) puts("Slytherin");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
bool cmp(int x, int y) { return x < y; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n, cmp);
printf("%d\n", min(abs(a[0] - a[n - 2]), abs(a[1] - a[n - 1])));
return 0;
}
| 0 |
#include <bits/stdc++.h>
int n, m;
int a[10], b[10], lena, lenb;
int f[10][1 << 7], g[10][1 << 7];
int dfs(int p, int up, int st, int x) {
if (!p) return 1;
if (x == 0) {
up = 1;
x = -1;
}
if (!up && g[p][st]) return f[p][st];
int stop = 6, temp = 0;
if (x > 0) {
if (up) stop = a[x];
for (int i = 0; i <= stop; i++)
if (!((st >> i) & 1))
temp += dfs(p - 1, up && (i == stop), st | (1 << i), x - 1);
} else {
if (up) stop = b[p];
for (int i = 0; i <= stop; i++)
if (!((st >> i) & 1))
temp += dfs(p - 1, up && (i == stop), st | (1 << i), x);
}
if (!up) {
g[p][st] = 1;
f[p][st] = temp;
}
return temp;
}
void Solve() {
n--;
m--;
for (int i = n; i; i /= 7) a[++lena] = i % 7;
for (int i = m; i; i /= 7) b[++lenb] = i % 7;
if (!n) lena++;
if (!m) lenb++;
if (lena + lenb > 7) {
printf("0\n");
return;
}
printf("%d\n", dfs(lena + lenb, 1, 0, lena));
}
int main() {
scanf("%d%d", &n, &m);
if (n >= 823544 || m >= 823544) {
printf("0\n");
return 0;
}
Solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 5;
int p[N], a[N], n, m, q[N], nxt[N], lst[N];
set<pair<int, int> > st;
bool cmp(int a, int b) { return p[a] < p[b]; };
int cal(int x, int y) {
if (x == y) return INF;
int d = (p[y] - p[x] + m) % m;
if (y < x) d = (d + a[y]) % m;
if (d <= a[x]) return 1;
if (a[x] <= a[y]) return INF;
return (d - a[y] - 1) / (a[x] - a[y]) + 1;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> p[i] >> a[i], p[i]--, q[i] = i;
sort(&q[1], &q[n + 1], cmp);
for (int i = 1; i <= n; i++) nxt[q[i]] = q[i + 1], lst[q[i]] = q[i - 1];
nxt[q[n]] = q[1];
lst[q[1]] = q[n];
for (int i = 1; i <= n; i++) st.insert({cal(i, nxt[i]), i});
while (1) {
pair<int, int> u = *st.begin();
if (u.first == INF) break;
int v = u.second;
st.erase(st.begin());
st.erase(make_pair(cal(nxt[v], nxt[nxt[v]]), nxt[v]));
if (!st.empty()) st.erase(make_pair(cal(lst[v], v), lst[v]));
p[v] += u.first;
p[v] %= m;
--a[v];
nxt[v] = nxt[nxt[v]];
lst[nxt[v]] = v;
st.insert(make_pair(cal(lst[v], v), lst[v]));
st.insert(make_pair(cal(v, nxt[v]), v));
}
cout << st.size() << endl;
for (set<pair<int, int> >::iterator it = st.begin(); it != st.end(); it++)
printf("%d ", it->second);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int dis[10010];
pair<int, int> p[10010];
queue<int> q;
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < k; i++) scanf("%d%d", &p[i].first, &p[i].second);
sort(p, p + k);
memset(dis, 0x3f, sizeof(dis));
dis[0] = 0;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
int ux = p[u].first, uy = p[u].second;
for (int v = 0; v < k; v++) {
int s = 1;
int vx = p[v].first, vy = p[v].second;
if (abs(ux - vx) > 2 && abs(uy - vy) > 2) continue;
if (ux == vx && abs(uy - vy) == 1) s = 0;
if (uy == vy && abs(ux - vx) == 1) s = 0;
if (dis[v] > dis[u] + s) {
dis[v] = dis[u] + s;
q.push(v);
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < k; i++) {
if (dis[i] == 0x3f3f3f3f) continue;
int ux = p[i].first, uy = p[i].second;
if (ux == n && uy == m) {
println(dis[i]);
return 0;
}
if (ux > n - 2 || uy > m - 2) smin(ans, dis[i] + 1);
}
if (ans == 0x3f3f3f3f) ans = -1;
println(ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast", "unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long inf = numeric_limits<long long>::max() / 2;
const long double eps = 1e-9;
const long double pi = acos(-1);
inline void solve(), read();
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read();
solve();
return 0;
}
long long gcd(long long a, long long b) {
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
pair<long long, long long> exgcd(long long a, long long b) {
if (a == 0) {
return {0, 1};
}
long long x0, y0;
tie(x0, y0) = exgcd(b % a, a);
long long x = y0 - b / a * x0;
long long y = x0;
return {x, y};
}
long long n, l, r, k;
long long x, y;
pair<long long, long long> solve(long long a, long long b, long long c) {
long long x, y;
tie(x, y) = exgcd(a, b);
long long g = gcd(a, b);
if (c % g != 0) {
return {-inf, -inf};
}
c /= g;
x *= c, y *= c;
return {x, y};
}
long long n2(long long f) {
if (f) {
++k;
}
long long ans = -1;
for (long long a = f; a <= x; a++) {
for (long long b = 0; b <= y; b++) {
if (k - x - a < 0 || (k - x - a) % (x + y + a + b) != 0) {
continue;
}
(ans) = ((ans) < (a + b)) ? (a + b) : (ans);
}
}
return ans;
}
long long nk(long long f) {
if (f) {
++k;
}
long long ans = -1;
if (k - x <= x) {
(ans) = ((ans) < (k - x + y)) ? (k - x + y) : (ans);
}
for (long long t = 1; t <= k / n; t++) {
long long c = k - t * n - x;
if (c < 0) {
continue;
}
long long a, b;
tie(a, b) = solve(t + 1, t, c);
if (a == -inf) {
continue;
}
a = (a % t + t) % t;
b = (c - a * (t + 1)) / t;
if (b > y) {
long long diff = b - y;
long long ch = (diff + t) / (t + 1);
b -= ch * (t + 1);
a += ch * t;
}
if (f && !a) {
continue;
}
if (0 <= a && a <= x && 0 <= b && b <= y) {
(ans) = ((ans) < (a + b)) ? (a + b) : (ans);
}
}
return ans;
}
inline void solve() {
x = (r - l + n) % n + 1;
y = n - x;
if (k < x) {
cout << -1 << "\n";
return;
}
long long ansk = -1, ansk1 = -1;
if (n <= 10000) {
ansk = n2(0);
ansk1 = n2(1);
} else {
ansk = nk(0);
ansk1 = nk(1);
}
long long ans = max(ansk, ansk1);
cout << ans << "\n";
}
inline void read() { cin >> n >> l >> r >> k; }
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dp[1000000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a;
cin >> a;
if (a == 1) {
cout << 1 << " ";
} else {
cout << 2 * (a - 1) << " ";
}
cout << 2 << endl;
cout << 1 << " " << 2;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int INP, AM, REACHEOF;
char BUF[(1 << 12) + 1], *inp = BUF;
const long double PI = acos((long double)-1.0);
int n, a[5], win[333][333];
int main() {
while (cin >> n) {
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
if (n == 1) {
if (a[1] == 0)
puts("BitAryo");
else
puts("BitLGM");
} else if (n == 2) {
memset(win, -1, sizeof win);
for (int i = (0), _b = (300); i <= _b; i++)
for (int j = (0), _b = (300); j <= _b; j++) {
win[i][j] = 0;
for (int ii = (0), _b = (i - 1); ii <= _b; ii++)
if (!win[ii][j]) {
win[i][j] = 1;
break;
}
for (int jj = (0), _b = (j - 1); jj <= _b; jj++)
if (!win[i][jj]) {
win[i][j] = 1;
break;
}
for (int x = (1), _b = (min(i, j)); x <= _b; x++)
if (!win[i - x][j - x]) {
win[i][j] = 1;
break;
}
}
if (win[a[1]][a[2]])
puts("BitLGM");
else
puts("BitAryo");
} else {
if (a[1] ^ a[2] ^ a[3])
puts("BitLGM");
else
puts("BitAryo");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long n, m, q, l, r;
long long vis[3 * maxn], cir[3 * maxn], suff[3 * maxn];
vector<long long> G[3 * maxn];
stack<long long> path;
void dfs(long long now, long long pre) {
path.push(now);
vis[now] = 1;
for (int i = 0; i < (int)G[now].size(); i++) {
long long Next = G[now][i];
if (Next == pre) continue;
if (!vis[Next]) dfs(Next, now);
if (vis[Next] == 1) {
long long maxc = now, minc = now;
while (!path.empty()) {
long long temp = path.top();
path.pop();
maxc = max(maxc, temp), minc = min(minc, temp);
if (temp == Next) break;
}
cir[minc] = maxc;
}
}
if (!path.empty() && path.top() == now) path.pop();
vis[now] = 2;
}
int main() {
scanf("%lld %lld", &n, &m);
for (int i = 1; i <= m; i++) {
long long u, v;
scanf("%lld %lld", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
memset(vis, 0, sizeof(vis));
for (int i = 0; i <= n + 1; i++) cir[i] = n + 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, 0);
}
suff[n] = suff[n + 1] = 0;
for (int i = n; i >= 1; i--) cir[i] = min(cir[i], cir[i + 1]);
for (int i = n; i >= 1; i--) suff[i] = cir[i] - i + suff[i + 1];
scanf("%lld", &q);
while (q--) {
scanf("%lld %lld", &l, &r);
long long L = l, R = r, p;
while (L <= R) {
long long m = (L + R) / 2;
if (cir[m] <= r) {
L = m + 1;
} else {
p = m;
R = m - 1;
}
}
long long ans = suff[l] - suff[p] + (r - p + 1) * (r - p + 2) / 2;
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int t, n;
string s;
while(cin >> t){
while(t--){
cin >> n;
cin >> s;
int totals = 0, ls, rs;
for(int i = 0; i < s.length(); i++){
if(s[i] == '*') totals++;
}
ls = 0; rs = totals;
long long ans = 0;
for(int i = 0; i < s.length();i++){
if(s[i]== '*'){
ls++; rs--;
}
else{
ans += ls > rs ? rs : ls;
}
}
cout << ans << "\n";
}
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long p, long long e, long long M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return ret;
}
long long extended(long long a, long long b, long long &x, long long &y) {
a = abs(a);
b = abs(b);
long long g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
long long modinverse(long long a, long long M) { return bigmod(a, M - 2, M); }
long long bpow(long long p, long long e) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
string convertInt(long long number) {
if (number == 0) return "0";
string temp = "";
string returnvalue = "";
while (number > 0) {
temp += number % 10 + 48;
number /= 10;
}
for (int i = 0; i < temp.length(); i++)
returnvalue += temp[temp.length() - i - 1];
return returnvalue;
}
long long ncr[1001][1001];
void NCR() {
for (int i = 1; i <= 1000; i++) {
ncr[i][i] = 1;
ncr[i][0] = 1;
for (int r = 1; r < i; r++) {
ncr[i][r] = (ncr[i - 1][r] + ncr[i - 1][r - 1]) % 1000000007;
}
}
}
string s[10], c[30];
int n, m, k, res, ind;
int inv[20];
void dfs(int x, int y) {
if (x == n) {
int val = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (inv[j] > inv[i]) val++;
}
}
if (res < (n - 1) * n / 2 - val + 1)
res = (n - 1) * n / 2 - val + 1, ind = y;
return;
}
for (int i = 0; i < k; i++) {
if (s[x] == c[i]) {
inv[x] = i;
dfs(x + 1, y);
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> k;
for (int j = 0; j < k; j++) {
cin >> c[j];
}
dfs(0, i + 1);
}
if (ind) {
cout << ind << endl << "[:" << string(res, '|') << ":]" << endl;
} else {
puts("Brand new problem!");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int arr[111];
int main() {
int n;
scanf("%d", &n);
arr[0] = 0;
for (int i = (1); i < (n + 1); ++i) scanf("%d", &arr[i]);
int ans = 0;
if (n % 2 == 0 || n == 1) {
printf("-1\n");
return 0;
}
for (int i = n; i >= 1; i -= 2) {
int tmp = max(arr[i], arr[i - 1]);
ans += tmp;
arr[i] = arr[i - 1] = 0;
arr[(i - 1) / 2] = max(0, arr[(i - 1) / 2] - tmp);
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
double EPS = 1e-7;
int INF = 1000000000;
long long INFLL = 1000000000000000000LL;
int mx[8] = {-1, 1, 0, 0, -1, -1, 1, 1};
int my[8] = {0, 0, -1, 1, -1, 1, -1, 1};
int cost[25][25];
int lvisit[25];
int rvisit[25];
int lvalue[25];
int rvalue[25];
int rmatch[25];
int m, n;
inline bool findmatch(int s) {
lvisit[s] = true;
for (int(i) = (0); (i) < (n); (i)++) {
if (rvisit[i] || lvalue[s] + rvalue[i] != cost[s][i]) continue;
rvisit[i] = true;
if (rmatch[i] == -1 || findmatch(rmatch[i])) {
rmatch[i] = s;
return true;
}
}
return false;
}
inline void normalize() {
int down = INF;
vector<int> lv;
for (int(i) = (0); (i) < (m); (i)++)
if (lvisit[i]) lv.push_back(i);
for (int(j) = (0); (j) < (n); (j)++)
if (!rvisit[j]) {
for (int(k) = (0); (k) < ((int)lv.size()); (k)++) {
int i = lv[k];
down = min(down, lvalue[i] + rvalue[j] - cost[i][j]);
}
}
for (int(i) = (0); (i) < (m); (i)++)
if (lvisit[i]) lvalue[i] -= down;
for (int(i) = (0); (i) < (n); (i)++)
if (rvisit[i]) rvalue[i] += down;
}
inline int calc() {
memset(rvalue, 0, sizeof(rvalue));
memset(rmatch, -1, sizeof(rmatch));
memset(lvalue, 0, sizeof(lvalue));
memset(lvisit, 0, sizeof(lvisit));
memset(rvisit, 0, sizeof(rvisit));
for (int(i) = (0); (i) < (m); (i)++)
lvalue[i] = *max_element(cost[i], cost[i] + n);
for (int(i) = (0); (i) < (m); (i)++) {
memset(lvisit, 0, sizeof(lvisit));
memset(rvisit, 0, sizeof(rvisit));
if (findmatch(i)) continue;
i--;
normalize();
}
int ret = 0;
for (int(i) = (0); (i) < (n); (i)++)
if (rmatch[i] != -1) ret += cost[rmatch[i]][i];
return ret;
}
int N, x, risan = -INF;
int satu[105][105], dua[105][105];
void dfs(int now, int nowa, int nowb) {
if (now == N) return;
if (nowa < N / 2) {
++m;
for (int(i) = (0); (i) < (n); (i)++) cost[now][i] = satu[now][i];
lvalue[now] = *max_element(cost[now], cost[now] + n);
while (1) {
memset(lvisit, 0, sizeof(lvisit));
memset(rvisit, 0, sizeof(rvisit));
if (findmatch(now)) break;
normalize();
}
int ret = 0;
for (int(i) = (0); (i) < (n); (i)++)
if (rmatch[i] != -1) ret += cost[rmatch[i]][i];
(risan) = max((risan), (ret));
dfs(now + 1, nowa + 1, nowb);
for (int(i) = (0); (i) < (n); (i)++)
if (rmatch[i] == now) rmatch[i] = -1;
--m;
}
if (nowb < N / 2) {
++m;
for (int(i) = (0); (i) < (n); (i)++) cost[now][i] = dua[now][i];
lvalue[now] = *max_element(cost[now], cost[now] + n);
while (1) {
memset(lvisit, 0, sizeof(lvisit));
memset(rvisit, 0, sizeof(rvisit));
if (findmatch(now)) break;
normalize();
}
int ret = 0;
for (int(i) = (0); (i) < (n); (i)++)
if (rmatch[i] != -1) ret += cost[rmatch[i]][i];
(risan) = max((risan), (ret));
dfs(now + 1, nowa, nowb + 1);
for (int(i) = (0); (i) < (n); (i)++)
if (rmatch[i] == now) rmatch[i] = -1;
--m;
}
}
int main() {
scanf("%d", &N);
n = N;
m = 0;
memset(rvalue, 0, sizeof(rvalue));
memset(rmatch, -1, sizeof(rmatch));
memset(lvalue, 0, sizeof(lvalue));
memset(lvisit, 0, sizeof(lvisit));
memset(rvisit, 0, sizeof(rvisit));
for (int(i) = (0); (i) < (N); (i)++)
for (int(j) = (0); (j) < (N); (j)++) {
scanf("%d", &satu[i][j]);
}
for (int(i) = (0); (i) < (N); (i)++)
for (int(j) = (0); (j) < (N); (j)++) {
scanf("%d", &dua[i][j]);
}
dfs(0, 0, 0);
printf("%d\n", risan);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 50;
const long long mod = 998244353;
const long long base = 1e18;
long long a[maxn];
long long b[maxn];
long long pos[maxn];
bool dd[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("t.inp", "r")) {
freopen("test.inp", "r", stdin);
freopen("test.out", "w", stdout);
}
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
set<long long> st;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
st.insert(i);
}
long long ans = 1;
for (int i = 1; i <= k; i++) {
cin >> b[i];
dd[pos[b[i]]] = 1;
}
for (int i = 1; i <= k; i++) {
if (st.count(pos[b[i]])) {
st.erase(pos[b[i]]);
auto it = st.lower_bound(pos[b[i]]);
long long h1 = -1;
long long h2 = -1;
if (it != st.end()) {
long long p = *it;
if (!dd[p]) {
h2 = p;
}
}
if (it != st.begin()) {
it--;
long long p = *it;
if (!dd[p]) {
h1 = p;
}
}
if (h1 == -1 && h2 == -1) {
ans = 0;
break;
} else if (h1 == -1 && h2 != -1) {
st.erase(h2);
} else if (h1 != -1 && h2 == -1) {
st.erase(h1);
} else {
ans = ans * 2;
ans %= mod;
st.erase(h1);
}
st.insert(pos[b[i]]);
dd[pos[b[i]]] = 0;
} else {
ans = 0;
break;
}
}
for (int i = 1; i <= n; i++) {
dd[i] = 0;
}
cout << ans << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long INF = 1e9 + 19;
int n;
long long r;
int l[N];
int t[N];
int need[N];
void read() {
scanf("%d%I64d", &n, &r);
for (int i = 0; i < n; i++) scanf("%d", &l[i]);
for (int i = 0; i < n; i++) scanf("%d", &t[i]);
}
void solve() {
for (int i = 0; i < n; i++) {
if (l[i] > t[i]) {
puts("-1");
return;
}
need[i] = max(0, l[i] * 2 - t[i]);
}
long long answer = 0;
vector<pair<long long, int>> b;
long long prev = 0;
long long curT = 0;
for (int i = 0; i < n; i++) {
long long sumPower = min(prev, l[i] * 1ll);
prev -= sumPower;
if (need[i] > sumPower) {
long long rem = need[i] - sumPower;
long long cnt = (rem + r - 1) / r;
answer += cnt;
sumPower += rem;
long long tEnd = curT + sumPower + (l[i] - sumPower) * 2;
b.push_back(make_pair(tEnd - rem, cnt));
assert(cnt * r >= rem);
prev = (cnt * r) - rem;
}
curT += sumPower + (l[i] - sumPower) * 2;
}
cout << answer << endl;
if (answer <= 1e5) {
for (auto x : b) {
for (int i = 0; i < x.second; i++) printf("%I64d ", x.first + i * r);
}
puts("");
}
}
void stress() {}
int main() {
if (1) {
int k = 1;
for (int tt = 0; tt < k; tt++) {
read();
solve();
}
} else {
stress();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
struct edge {
int v = 0, nx = 0;
} E[N << 1];
struct ver {
int h = 0, f = 0;
} a[N];
int n, q, r, l = 0;
void vis(const int &u, const int &p) {
a[u].f = p;
for (int e = a[u].h; e; e = E[e].nx) {
int v = E[e].v;
if (!a[v].f) vis(v, (p < v ? p : v));
}
}
void ne(int k, const int &u, const int &v) {
E[k].v = v;
E[k].nx = a[u].h;
a[u].h = k;
++k;
E[k].v = u;
E[k].nx = a[v].h;
a[v].h = k;
}
int main() {
scanf("%d%d", &n, &q);
int i, j = 0;
for (int k = 1; k < n; ++k) scanf("%d%d", &i, &j), ne(k << 1, i, j);
scanf("%d%d", &j, &i);
l = 0;
i = (i + l) % n + 1;
r = i;
vis(i, r);
while (--q) {
scanf("%d%d", &i, &j);
j = (j + l) % n + 1;
if (i == 1)
r = (r < a[j].f ? r : a[j].f);
else
printf("%d\n", l = (r < a[j].f ? r : a[j].f));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int arr[6][8] = {
{13, 14, 5, 6, 17, 18, 21, 22}, {15, 16, 7, 8, 19, 20, 23, 24},
{1, 3, 5, 7, 9, 11, 24, 22}, {2, 4, 6, 8, 10, 12, 23, 21},
{9, 10, 19, 17, 4, 3, 14, 16}, {11, 12, 20, 18, 2, 1, 13, 15}};
int mapp[25];
int fmapp[25];
int check() {
for (int i = 1; i <= 24; i++) {
if (mapp[i] != mapp[(i - 1) / 4 * 4 + 1]) return 0;
}
return 1;
}
int solve(int k, int dir) {
if (dir == 1) {
int p = mapp[arr[k][0]], q = mapp[arr[k][1]];
for (int i = 0; i < 6; i++) {
mapp[arr[k][i]] = mapp[arr[k][i + 2]];
}
mapp[arr[k][6]] = p;
mapp[arr[k][7]] = q;
} else {
int p = mapp[arr[k][6]], q = mapp[arr[k][7]];
for (int i = 7; i >= 2; i--) mapp[arr[k][i]] = mapp[arr[k][i - 2]];
mapp[arr[k][1]] = q;
mapp[arr[k][0]] = p;
}
return check();
}
int minn(int a, int b) {
if (a > b) return b;
return a;
}
int maxx(int a, int b) {
if (a < b) return b;
return a;
}
int main() {
for (int i = 1; i <= 24; i++) cin >> mapp[i];
for (int t = 0; t < 25; t++) fmapp[t] = mapp[t];
for (int i = 0; i < 6; i++) {
if (solve(i, -1)) {
cout << "YES" << endl;
return 0;
}
for (int t = 0; t < 25; t++) mapp[t] = fmapp[t];
if (solve(i, 1)) {
cout << "YES" << endl;
return 0;
}
for (int t = 0; t < 25; t++) mapp[t] = fmapp[t];
}
cout << "NO" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos((long double)-1);
long double dis(long long x1, long long y1, long long x2, long long y2) {
return sqrt((long double)(x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long x1, y1, r1;
cin >> x1 >> y1 >> r1;
long long x2, y2, r2;
cin >> x2 >> y2 >> r2;
long double ans, rr = dis(x1, y1, x2, y2);
if (rr >= r1 + r2) {
ans = 0;
} else if (rr + min(r1, r2) <= max(r1, r2)) {
ans = min(r1, r2) * min(r1, r2) * PI;
} else {
long double deg1 =
acos((long double)(rr * rr + r1 * r1 - r2 * r2) / (2 * r1 * rr));
long double deg2 =
acos((long double)(rr * rr + r2 * r2 - r1 * r1) / (2 * r2 * rr));
long double mian1 = r1 * r1 * deg1 - r1 * r1 * sin(deg1 * 2) / 2;
long double mian2 = r2 * r2 * deg2 - r2 * r2 * sin(deg2 * 2) / 2;
ans = mian1 + mian2;
}
cout << fixed << setprecision(20) << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int maxx = 1e7 + 5;
int n;
vector<int> a;
set<int> b;
set<int> c;
set<int> d;
long long check(vector<int> &a) {
for (int i = 0; i < (a.size()); ++i) {
c.clear();
c.insert(a[i]);
for (set<int>::iterator it = b.begin(); it != b.end(); it++)
c.insert(*it | a[i]);
b.clear();
for (set<int>::iterator it = c.begin(); it != c.end(); it++) {
b.insert(*it);
d.insert(*it);
}
}
return d.size();
}
int main() {
int v;
cin >> n;
for (int i = 0; i < (n); ++i) {
scanf("%d", &v);
a.push_back(v);
}
cout << check(a) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N;
int arr[1000005];
priority_queue<int, vector<int>, greater<int>> pq;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> N;
long long crnt = 0, add = 0, sub = 0;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
crnt += abs(i - arr[i]);
if (arr[i] > i) {
add++;
} else {
sub++;
}
pq.push(i - arr[i] + 1 <= 0 ? i + N - arr[i] + 1 : i - arr[i] + 1);
}
long long ans = LLONG_MAX / 2, idx = 0;
for (int i = 1; i <= N; i++) {
if (ans > crnt) {
idx = i - 1;
ans = crnt;
}
while (pq.size() && pq.top() == i) {
pq.pop();
sub--;
add++;
}
crnt -= arr[i] - 1;
crnt += N - arr[i];
sub++;
add--;
crnt += add - sub + 1;
}
cout << ans << " " << (N - idx) % N << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int idx = 1 << 30;
set<string> Set;
vector<string> v1;
vector<vector<string> > arch;
vector<string> vs;
int sim = 1 << 30;
int totalinv = 1 << 30;
vector<vector<string> > modes;
int inv(vector<string> t) {
int cnt = 0;
for (int i = 0; i < v1.size(); i++) {
for (int j = i + 1; j < v1.size(); j++) {
int k1, k2;
for (int k = 0; k < v1.size(); k++) {
if (t[k] == vs[i]) k1 = k;
if (t[k] == vs[j]) k2 = k;
}
if (k1 > k2) {
cnt++;
}
}
}
return cnt;
}
bool isSub(vector<string> v1, vector<string> v2) {
int K = 0;
for (int i = 0; i < v1.size();) {
if (K >= v2.size()) return false;
if (v1[i] == v2[K]) {
i += 1;
K += 1;
} else
K += 1;
}
return true;
}
int main(void) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
Set.insert(t);
v1.push_back(t);
vs.push_back(t);
}
sort(v1.begin(), v1.end());
do {
modes.push_back(v1);
} while (next_permutation(v1.begin(), v1.end()));
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int l;
cin >> l;
vector<string> temp;
for (int j = 0; j < l; j++) {
string t;
cin >> t;
temp.push_back(t);
}
arch.push_back(temp);
}
for (int i = 0; i < modes.size(); i++) {
for (int j = 0; j < arch.size(); j++) {
if (isSub(modes[i], arch[j])) {
int iv = inv(modes[i]);
if (iv == totalinv) {
idx = min(j, idx);
}
if (iv < totalinv) {
idx = j;
totalinv = iv;
sim = ((modes[i].size() * (modes[i].size() - 1)) / 2) - iv + 1;
}
}
}
}
if (sim == (1 << 30)) {
cout << "Brand new problem!" << endl;
} else {
cout << idx + 1 << endl;
cout << "[:";
for (int i = 0; i < sim; i++) cout << "|";
cout << ":]" << endl;
}
return 0;
}
| 9 |
#include <iostream>
using namespace std;
int main(){
int t; cin>>t;
while(t--){
int n; cin>>n;
int arr[101];
for(int i=1; i<=n; i++) arr[i] = i;
if(n%2==0){
for(int i=1; i<=n; i+=2) swap(arr[i], arr[i+1]);
}
else{
for(int i=1; i<n; i+=2) swap(arr[i], arr[i+1]);
swap(arr[n-1], arr[n]);
}
for(int i=1; i<=n; i++) cout<<arr[i]<<" ";
cout<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
long long cal[maxn];
inline int lowbit(int x) { return x & (-x); }
long long getsum(int x) {
long long s = 0;
for (; x > 0; x -= lowbit(x)) s += cal[x];
return s;
}
void update(int x, int value) {
for (; x <= maxn; x += lowbit(x)) cal[x] += value;
}
struct node {
int l, r, xu, res;
} q[100100];
int cmp(struct node a, struct node b) { return a.l > b.l; }
int cmp1(struct node a, struct node b) { return a.xu < b.xu; }
char s[1000100];
int len;
int top;
int sta[1000100];
int main() {
int m, j, i;
while (scanf("%s", s) != EOF) {
memset(cal, 0, sizeof(cal));
memset(sta, 0, sizeof(sta));
top = 0;
len = strlen(s);
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].xu = i;
q[i].l--;
q[i].r--;
}
sort(q, q + m, cmp);
j = 0;
for (i = len - 1; i >= 0; i--) {
if (s[i] == ')')
sta[top++] = i;
else if (top > 0) {
top--;
update(sta[top], 1);
}
while (j < m && q[j].l == i) {
q[j].res = getsum(q[j].r);
j++;
}
}
sort(q, q + m, cmp1);
for (i = 0; i < m; i++) {
printf("%d\n", q[i].res * 2);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 100005;
vector<int> v[maxn];
int s[maxn], a[maxn];
int n, m, k;
int main() {
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (int i = 1; i <= m; i++) v[i].clear();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v[a[i]].push_back(i);
s[i] = (int)v[a[i]].size() - 1;
}
int Max = 0;
for (int i = 1; i <= n; i++) {
int l = s[i], r = (int)v[a[i]].size() - 1;
int ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
int len = (v[a[i]][mid] - i + 1);
int num = s[v[a[i]][mid]] - s[i] + 1;
if (len - num <= k) {
ans = num;
l = mid + 1;
} else
r = mid - 1;
}
Max = max(Max, ans);
}
cout << Max << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t, n, d;
cin >> t;
while (t--) {
cin >> n >> d;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int i = 1;
long long int ans = a[0];
while (d && i < n) {
ans += min(d / i, a[i]);
d -= (min(d / i, a[i]) * i);
i++;
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int binomialCoeff(long long int n, long long int k) {
long long int C[n + 1][k + 1];
long long int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] % 1000000007 + C[i - 1][j] % 1000000007) %
1000000007;
}
C[i][j] = C[i][j] % 1000000007;
}
return C[n][k] % 1000000007;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int power(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % 1000000007;
base = (base * base) % 1000000007;
exp /= 2;
}
return res % 1000000007;
}
long long int d[400001] = {0};
long long int b[400001] = {0};
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
greater<pair<long long int, long long int> > >
gq;
void chatur() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k = 0, g = 0, j, ans, q, i, m, w, o, p;
cin >> n;
for (long long int i = 0; i < 60; i++) {
if (n % (long long int)pow(3, i) != 0) {
cout << n / (long long int)pow(3, i) + 1;
break;
}
}
}
signed main() {
int test = 1;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (test--) chatur();
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, m;
scanf("%d%d", &n, &m);
std::vector<std::vector<int>> graph(n);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
graph.at(a).push_back(b);
graph.at(b).push_back(a);
}
std::vector<int> color(n, -1);
bool ok = true;
for (int s = 0; s < n && ok; ++s) {
if (!~color[s]) {
std::vector<int> queue;
queue.push_back(s);
color[s] = 0;
for (int h = 0; h < static_cast<int>(queue.size()); ++h) {
auto u = queue[h];
for (int v : graph.at(u)) {
if (!~color[v]) {
color[v] = color[u] ^ 1;
queue.push_back(v);
}
ok &= color[u] != color[v];
}
}
}
}
if (ok) {
std::vector<std::vector<int>> result(2);
for (int i = 0; i < n; ++i) {
result[color[i]].push_back(i);
}
for (int i = 0; i < 2; ++i) {
printf("%d\n", static_cast<int>(result[i].size()));
for (auto&& v : result[i]) {
printf("%d ", v + 1);
}
puts("");
}
} else {
puts("-1");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
long double pi = 3.1415926535897932384626433832795;
long long mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long _gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long _x1, _y1;
long long d = _gcd(b % a, a, _x1, _y1);
x = _y1 - (b / a) * _x1;
y = _x1;
return d;
}
long double binpow(long double a, long long n) {
long double res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
}
return res;
}
const int N = 3e5 + 10;
long long a[N], b[N], sa = 0, sb = 0;
long long n, p;
bool ok(long double t) {
long double have = t * p;
long double need = 0;
for (int i = 0; i < n; i++) {
need += max((long double)0, a[i] * t - b[i]);
}
return need <= have;
}
int main() {
cin >> n >> p;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
sa += a[i];
sb += b[i];
}
if (p >= sa) {
cout << -1;
} else {
long double l = 0, r = 1e18;
for (int ii = 0; ii < 200; ii++) {
long double mid = (l + r) / 2;
if (ok(mid))
l = mid;
else
r = mid;
}
printf("%.9f", (double)l);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005], b[100005];
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
long long num, cnt;
num = cnt = 0;
while (n) {
if (n % 2 == 1) cnt++;
a[num++] = n % 2;
n /= 2;
}
if (cnt > k) {
printf("No\n");
return 0;
}
printf("Yes\n");
int mini;
for (long long i = 0; i < num; i++) {
b[i] = a[num - i - 1];
if (b[i]) mini = i;
}
for (long long i = 0;; i++) {
if (cnt == k) break;
if (k - cnt >= b[i]) {
cnt += b[i];
b[i + 1] += b[i] * 2;
b[i] = 0;
} else
break;
if (i + 1 > mini) mini = i + 1;
}
while (cnt != k) {
cnt++;
b[mini]--;
b[mini + 1] += 2;
mini++;
}
long long t;
for (long long i = 0; i <= mini; i++) {
while (b[i]) {
b[i]--;
t = num - 1 - i;
printf("%lld ", t);
}
}
printf("\n");
return 0;
}
| 6 |
#include<bits/stdc++.h>
#include <string>
#include <unordered_map>
#include <queue>
using namespace std;
#define ll long long int
#define ull unsigned long long int
ll prime = 998244353;
ll modulo = 1e9 + 7;
//int fact[1000001];
bool sortbysec(const pair<int,int> &a,
const pair<int,int> &b)
{
return (a.second < b.second);
}
int g(int good ,int x){
int tmp;
for(int j=1 ; j<4 ;j++){
if(j !=good && j!= x ){tmp = j;break;}
}
return tmp;
};
void solve(){
unordered_map<string,int> look_up;
unordered_map<ll ,int> lp;
int n;
cin >> n;
int nn =n*n;
int col , cnt1 =0,cnt2=0;
//int type[4]={0};
int fp = 1,sp = 2,frow =1,fcol = 1, srow = 1,scol = 2;
for(int i= 0 ; i<nn ; i++){
cin >> col;
// put 2 on the first cell
if( (col == 1 || col == 3) && cnt1 < ceil(nn/(double)2) ){
cout << 2 << " "<< frow << " " << fcol << endl;
cout.flush();
cnt1++ ;
fcol+=2;
if(fcol > n){
frow++;
if(frow % 2 == 0)fcol = 2;
else fcol = 1;
}
}
else if( (col == 2 || col == 3) && cnt2 < nn/2 ){
cout << 1 << " " << srow << " " << scol << endl;
cout.flush();
cnt2++;
scol+=2;
if(scol > n){
srow++;
if(srow%2 == 0)scol = 1;
else scol = 2;
}
}
else if ( cnt1 == ceil(nn/(double)2) && col == 1 ){
cout << 3 << " " << srow << " " << scol << endl;
cout.flush();
cnt2++;
scol+=2;
if(scol > n){
srow++;
if(srow%2 == 0)scol = 1;
else scol = 2;
}
}
else if( cnt2 == nn/2 && col == 2){
cout << 3 << " "<< frow << " " << fcol << endl;
cout.flush();
cnt1++ ;
fcol+=2;
if(fcol > n){
frow++;
if(frow % 2 == 0)fcol = 2;
else fcol = 1;
}
}
}
//cout << "\n";
/*
2
1 2 1 3
1 1 2 1 2 3 2 2 2
*/
}
int main()
{
//ios::sync_with_stdio(0);
//cin.tie(0);
//cout.tie(0);
ll t;
//cin >> t;
//while(t--)
solve();
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, k, a[N];
double b[N], v[N];
long long s[N];
double f[N][51];
struct line {
long long a;
double b;
line(long long a = 0, double b = 0) : a(a), b(b) {}
};
bool bad(line l1, line l2, line l3) {
return (double)(l1.b - l3.b) / (l3.a - l1.a) <
(double)(l2.b - l1.b) / (l1.a - l2.a);
}
vector<line> L;
void add(line d) {
while (L.size() >= 2 && bad(L[L.size() - 2], L[L.size() - 1], d))
L.pop_back();
L.push_back(d);
}
double F(int pos, double x) {
if (pos == L.size())
return 1e18;
else
return L[pos].a * x + L[pos].b;
}
double get(double x) {
int l = 0, r = L.size();
while (l < r) {
int mid = ((l + r) >> 1);
if (F(mid, x) <= F(mid + 1, x))
r = mid;
else
l = mid + 1;
}
return F(l, x);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i], s[i] = s[i - 1] + a[i];
for (int i = 1; i <= n; ++i)
b[i] = b[i - 1] + (double)1.0 / a[i], v[i] = v[i - 1] + (double)s[i] / a[i];
for (int i = 1; i <= k; ++i) f[0][i] = 1e18;
for (int i = 1; i <= n; ++i) f[i][0] = 1e18;
for (int t = 1; t <= k; ++t) {
L.clear();
L.push_back(line(0, f[0][t - 1]));
for (int i = 1; i <= n; ++i) {
f[i][t] = get(b[i]) + v[i];
add(line(-s[i], f[i][t - 1] - v[i] + (double)s[i] * b[i]));
}
}
cout << setprecision(4) << fixed << f[n][k] << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime(int i) {
if (i <= 1) return false;
for (int j = 2; j < i; ++j) {
if (i % j == 0) return false;
}
return true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = n + 1; i <= m; ++i) {
if (is_prime(i)) {
if (i == m) {
cout << "YES" << endl;
return 0;
} else {
break;
}
}
}
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long jmp[200004], ans[200004], a[200004], t[200004], r[200004], ind, maxi,
p[200004];
int main() {
long long n, m, i, j, k, temp, s, e;
scanf("%lld %lld", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
p[i - 1] = a[i];
}
for (i = 1; i <= m; i++) {
scanf("%lld %lld", &t[i], &r[i]);
t[i]--;
}
ind = m + 1;
maxi = 0;
jmp[m] = m + 1;
for (i = m; i >= 0; i--) {
jmp[i] = ind;
if (r[i] > maxi) {
maxi = r[i];
ind = i;
}
}
i = 0;
i = jmp[i];
long long prev;
if (t[i] == 0) {
prev = 0;
s = 1;
e = r[i];
sort(p, p + e);
} else {
prev = 1;
s = r[i];
e = 1;
sort(p, p + s);
}
i = jmp[i];
while (i <= m) {
if (t[i] == 0) {
if (prev == 1) {
temp = s;
k = r[i];
for (j = s - r[i]; j >= e; j--) {
ans[++k] = j;
}
s = s - r[i] + 1;
e = temp;
}
prev = 0;
} else {
if (prev == 0) {
temp = s;
k = r[i];
for (j = s + r[i]; j <= e; j++) {
ans[++k] = j;
}
s = s + r[i] - 1;
e = temp;
}
prev = 1;
}
i = jmp[i];
}
if (prev == 1) {
j = 1;
for (i = s; i >= e; i--) {
ans[j++] = i;
}
} else {
j = 1;
for (i = s; i <= e; i++) {
ans[j++] = i;
}
}
for (i = 1; i <= n; i++) {
if (ans[i] == 0) {
printf("%lld ", a[i]);
} else
printf("%lld ", p[ans[i] - 1]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
cin >> n >> m;
vector<int> c(n);
vector<int> a(m);
for (i = 0; i < n; i++) cin >> c[i];
for (i = 0; i < m; i++) cin >> a[i];
if (m == 0 || n == 0)
cout << 0;
else {
i = 0;
j = 0;
int bill = a[j], count = 0;
while (i < n && j < m) {
if (bill >= c[i]) {
count++;
j++;
if (j == m) break;
bill = a[j];
}
i++;
}
cout << count;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300011;
const int oo = 2e9;
const int LOGN = 18;
int n, k, s[11];
struct group {
vector<int> mn, mx;
int sz;
group() {
sz = 1;
mn.resize(k);
mx.resize(k);
}
bool canBeat(const group &b) const {
for (int i = 0; i < b.mn.size(); ++i) {
if (mx[i] > b.mn[i]) return true;
}
return false;
}
void uni(group a) {
sz += a.sz;
for (int i = 0; i < a.mn.size(); ++i) {
mn[i] = min(mn[i], a.mn[i]);
mx[i] = max(mx[i], a.mx[i]);
}
}
bool operator<(const group &rhs) const {
return rhs.canBeat(*this) && !canBeat(rhs);
}
};
int main() {
scanf("%d%d", &n, &k);
multiset<group> g;
for (int i = 0; i < n; ++i) {
group cur;
for (int j = 0; j < k; ++j) {
scanf("%d", &cur.mn[j]);
cur.mx[j] = cur.mn[j];
}
multiset<group>::iterator it = g.upper_bound(cur);
vector<multiset<group>::iterator> rem;
while (it != g.begin()) {
--it;
if ((*it).canBeat(cur) && cur.canBeat(*it)) {
rem.push_back(it);
cur.uni(*it);
} else {
break;
}
}
while (rem.size()) {
g.erase(rem.back());
rem.pop_back();
}
g.insert(cur);
printf("%d\n", (*--g.end()).sz);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using i64 = long long;
i64 n, d1, d2;
struct Point {
i64 x, y;
};
Point operator-(const Point &a, const Point &b) {
return {a.x - b.x, a.y - b.y};
}
i64 operator*(const Point &a, const Point &b) { return a.x * b.x + a.y * b.y; }
i64 hyp(const Point &a) { return a.x * a.x + a.y * a.y; }
bool ok(const Point &p, const Point &q) {
auto theta = std::min((p - q) * p, (q - p) * q);
if (theta < 0) {
return std::min(hyp(p), hyp(q)) <= d1 * d1;
} else {
auto a = p.y - q.y, b = -(p.x - q.x), c = p.x * q.y - p.y * q.x;
return c * c <= d1 * d1 * (a * a + b * b);
}
}
int main() {
scanf("%lld%lld%lld", &n, &d1, &d2);
i64 state = 1;
i64 ax, ay, bx, by;
i64 ret = 0;
scanf("%lld%lld%lld%lld", &ax, &ay, &bx, &by);
Point pp{bx - ax, by - ay};
if (hyp(pp) <= d1 * d1) {
ret++;
state = 0;
}
while (--n) {
scanf("%lld%lld%lld%lld", &ax, &ay, &bx, &by);
Point cp{bx - ax, by - ay};
if (state) {
if (ok(cp, pp)) {
ret++;
if (hyp(cp) <= d2 * d2) state = 0;
}
} else {
if (hyp(cp) > d2 * d2) state = 1;
}
pp = cp;
}
printf("%d\n", ret);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d;
inline long long calc(long long i) {
return -(i + 1) * a + (i + 1) * i / 2 * b * d;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
if (a > b * c) {
puts("-1");
continue;
}
long long t = c / d;
long long lo = 0, hi = t;
while (hi - lo > 0) {
long long mid = (lo + hi) / 2;
if (calc(mid) > calc(mid + 1)) {
lo = mid + 1;
} else {
hi = mid;
}
}
long long ans = calc(hi);
printf("%lld\n", -ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void display(vector<int> &a) {
for (int z : a) cout << z << " ";
cout << endl;
}
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
const int mod = 998244353;
const long long INF64 = 3e18;
void smxl(long long &a, long long b) {
if (a < b) a = b;
}
void smnl(long long &a, long long b) {
if (a > b) a = b;
}
void adsl(long long &a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
void misl(long long &a, long long b) {
a -= b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
void smx(long long &a, long long b) {
if (a < b) a = b;
}
void smn(long long &a, long long b) {
if (a > b) a = b;
}
void ads(long long &a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
void mis(long long &a, long long b) {
a -= b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long egcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = egcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long mbinp(long long a, long long b) {
a %= mod;
if (b == 0) return 1;
long long ans = mbinp(a, b / 2);
long long tmp = (ans * ans) % mod;
if (b % 2) return ((tmp * a) % mod);
return ((tmp) % mod);
}
long long binp(long long a, long long b) {
if (b == 0) return 1;
long long ans = binp(a, b / 2);
long long tmp = (ans * ans);
if (b % 2) return ((tmp * a));
return ((tmp));
}
long long C(int n, int m) {
long long ret = 1;
for (int i = 1; i <= m; i++) {
ret *= (n - i + 1);
ret /= i;
}
return ret;
}
long long overbinp(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) {
if (res < INF64 / a)
res *= a;
else
return INF64;
}
if (b > 1) {
if (a < INF64 / a)
a *= a;
else
return INF64;
}
b >>= 1;
}
return res;
}
class DSU {
vector<int> par;
vector<int> siize;
public:
DSU(int n) {
par.resize(n);
siize.resize(n);
for (int i = 0; i < n; i++) {
par[i] = i;
siize[i] = 1;
}
}
public:
int get(int x) { return (x == par[x] ? x : par[x] = get(par[x])); }
public:
void merge(int a, int b) {
int x = get(a);
int y = get(b);
if (x == y) return;
if (siize[x] < siize[y]) swap(x, y);
par[y] = x;
siize[x] += siize[y];
}
};
class BinaryLift {
vector<vector<int> > binlift;
int n;
public:
BinaryLift(vector<int> rnk, vector<int> par) {
n = (int)par.size();
binlift.resize(n);
for (int i = 0; i < n; i++) binlift[i].resize(20);
for (int i = 0; i < n; i++) binlift[i][0] = par[i];
for (int j = 1; j < 20; j++)
for (int i = 0; i < n; i++) {
if ((1 << j) < rnk[i])
binlift[i][j] = binlift[binlift[i][j - 1]][j - 1];
else
binlift[i][j] = -1;
}
}
public:
int get_kth_ancestor(int x, int k) {
int pt = x;
for (int i = 19; i >= 0; i--) {
if (pt == -1) exit(0);
if (k & (1 << i)) pt = binlift[pt][i];
}
return pt;
}
public:
int get_th_ancestor(int x, int k) {
int pt = x;
for (int i = 19; i >= 0; i--) {
if (k & (1 << i)) pt = binlift[pt][i];
}
return pt;
}
};
class SparseTable2D {
vector<vector<vector<vector<int> > > > sparse;
vector<vector<int> > inp;
int m, n;
private:
int lg2(int x) {
int out = 0;
while ((1 << out) <= x) out++;
return out - 1;
}
public:
int rmin(int x1, int y1, int x2, int y2) {
int lenx = x2 - x1 + 1;
int lx = lg2(lenx) + 1;
int leny = y2 - y1 + 1;
int ly = lg2(leny) + 1;
return min(
min(sparse[lx][x1][ly][y1], sparse[lx][x1][ly][y2 + 1 - (1 << ly)]),
min(sparse[lx][x2 + 1 - (1 << lx)][ly][y1],
sparse[lx][x2 + 1 - (1 << lx)][ly][y2 + 1 - (1 << ly)]));
}
public:
SparseTable2D(vector<vector<int> > input, string param) {
n = input.size();
m = input[0].size();
inp = input;
if (param == "min") prepromin();
}
private:
void prepromin() {
int lln, lm;
lln = lg2(n) + 1;
lm = lg2(m) + 1;
sparse.resize(lln);
for (int i = 0; i < lln; i++) sparse[i].resize(n);
for (int i = 0; i < lln; i++)
for (int j = 0; j < n; j++) sparse[i][j].resize(lm);
for (int i = 0; i < lln; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < lm; k++) sparse[i][j][k].resize(m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) sparse[0][i][0][j] = inp[i][j];
for (int j = 1; j < lm; j++)
for (int k = 0; k + (1 << j) - 1 < m; k++)
sparse[0][i][j][k] = min(sparse[0][i][j - 1][k],
sparse[0][i][j - 1][k + (1 << (j - 1))]);
}
for (int i = 1; i < lln; i++)
for (int j = 0; j + (1 << i) - 1 < n; j++)
for (int k = 0; k < lm; k++)
for (int h = 0; h < m; h++)
sparse[i][j][k][h] = min(sparse[i - 1][j][k][h],
sparse[i - 1][j + (1 << (i - 1))][k][h]);
}
};
class SparseTable {
vector<vector<long long> > sparse;
int n;
vector<int> input;
private:
int lg2(int x) {
int out = 0;
while ((1 << out) <= x) out++;
return out - 1;
}
public:
int rmaxpos(int left, int right) {
int len = right - left + 1;
int lg = lg2(len);
return (input[sparse[left][lg]] > input[sparse[left + len - (1 << lg)][lg]]
? sparse[left][lg]
: sparse[left + len - (1 << lg)][lg]);
}
public:
int rmaxval(int left, int right) {
int len = right - left + 1;
int lg = lg2(len);
return (input[sparse[left][lg]] > input[sparse[left + len - (1 << lg)][lg]]
? input[sparse[left][lg]]
: input[sparse[left + len - (1 << lg)][lg]]);
}
public:
int rminpos(int left, int right) {
int len = right - left + 1;
int lg = lg2(len);
return (input[sparse[left][lg]] < input[sparse[left + len - (1 << lg)][lg]]
? sparse[left][lg]
: sparse[left + len - (1 << lg)][lg]);
}
public:
int rminval(int left, int right) {
int len = right - left + 1;
int lg = lg2(len);
return (input[sparse[left][lg]] < input[sparse[left + len - (1 << lg)][lg]]
? input[sparse[left][lg]]
: input[sparse[left + len - (1 << lg)][lg]]);
}
public:
long long rsum(int left, int right) {
long long ans = 0;
int pos;
while (left <= right) {
for (int i = 19; i >= 0; i--)
if ((1 << i) <= right - left + 1) {
pos = i;
break;
}
ans += sparse[left][pos];
left = left + (1 << pos);
}
return ans;
}
public:
SparseTable(vector<int> inp, string operation) {
input = inp;
n = inp.size();
if (operation == "min")
prepromin();
else if (operation == "max")
prepromax();
else if (operation == "sum")
preprosum();
}
private:
void prepromin() {
sparse.resize(n);
int x = lg2(n) + 1;
for (int i = 0; i < n; i++) sparse[i].resize(x);
for (int i = 0; i < n; i++) sparse[i][0] = i;
for (int j = 1; j < x; j++)
for (int i = 0; i + (1 << (j)) - 1 < n; i++)
sparse[i][j] =
(input[sparse[i][j - 1]] < input[sparse[i + (1 << (j - 1))][j - 1]]
? sparse[i][j - 1]
: sparse[i + (1 << (j - 1))][j - 1]);
}
void prepromax() {
sparse.resize(n);
int x = lg2(n) + 1;
for (int i = 0; i < n; i++) sparse[i].resize(x);
for (int i = 0; i < n; i++) sparse[i][0] = i;
for (int j = 1; j < x; j++)
for (int i = 0; i + (1 << (j)) - 1 < n; i++)
sparse[i][j] =
(input[sparse[i][j - 1]] > input[sparse[i + (1 << (j - 1))][j - 1]]
? sparse[i][j - 1]
: sparse[i + (1 << (j - 1))][j - 1]);
}
void preprosum() {
sparse.resize(n);
int x = lg2(n) + 1;
for (int i = 0; i < n; i++) sparse[i].resize(x);
for (int i = 0; i < n; i++) sparse[i][0] = input[i];
for (int j = 1; j < x; j++)
for (int i = 0; i + (1 << (j)) - 1 < n; i++)
sparse[i][j] = sparse[i][j - 1] + sparse[i + (1 << (j - 1))][j - 1];
}
};
class Vector {
public:
pair<long long, long long> x;
public:
Vector(pair<long long, long long> a, pair<long long, long long> b) {
x.first = b.first - a.first;
x.second = b.second - a.second;
}
public:
long double getMagnitude() {
return sqrtl(x.first * x.first + x.second * x.second);
}
};
class Line {
public:
pair<long long, long long> x, y;
public:
Line(pair<long long, long long> a, pair<long long, long long> b) {
x = a;
y = b;
}
private:
long double dotProduct(Vector a, Vector b) {
return a.x.first * b.x.first + a.x.second * b.x.second;
}
private:
long double crossProduct(Vector a, Vector b) {
return a.x.first * b.x.second - a.x.second * b.x.first;
}
private:
long double magnitude(Vector a) { return a.getMagnitude(); }
public:
long double distanceToA(pair<long long, long long> c) {
return dotProduct(Vector(x, y), Vector(x, c)) / magnitude(Vector(x, y));
}
public:
long double orthogonalDistance(pair<long long, long long> c) {
return crossProduct(Vector(x, y), Vector(x, c)) / magnitude(Vector(x, y));
}
public:
pair<long double, long double> intersection(Line l) {
pair<long double, long double> ans;
ans.first = (long double)((x.first * y.second - x.second * y.first) *
(l.x.first - l.y.first) -
(x.first - y.first) * (l.x.first * l.y.second -
l.x.second * l.y.first)) /
((x.first - y.first) * (l.x.second - l.y.second) -
(x.second - y.second) * (l.x.first - l.y.first));
ans.second =
(long double)((x.first * y.second - x.second * y.first) *
(l.x.second - l.y.second) -
(x.second - y.second) *
(l.x.first * l.y.second - l.x.second * l.y.first)) /
((x.first - y.first) * (l.x.second - l.y.second) -
(x.second - y.second) * (l.x.first - l.y.first));
return ans;
}
};
class PruferCode {
vector<int> code;
vector<pair<int, int> > edges;
public:
PruferCode(vector<int> cc) {
code = cc;
findEdges();
}
private:
void findEdges() {
map<int, int> mp;
set<int> has;
set<int> wait;
for (int z : code) {
mp[z]++;
has.insert(z);
}
for (int i = 0; i < code.size() + 2; i++)
if (!has.count(i)) wait.insert(i);
for (int i = 0; i < code.size(); i++) {
int now = *wait.begin();
edges.push_back(make_pair(now, code[i]));
mp[now]++;
mp[code[i]]--;
if (mp[code[i]] == 0) {
has.erase(code[i]);
wait.insert(code[i]);
}
wait.erase(now);
}
assert(wait.size() == 2);
edges.push_back(make_pair(*wait.begin(), *wait.rbegin()));
}
public:
vector<pair<int, int> > getEdges() { return edges; }
};
class Segment {
pair<long long, long long> x, y;
public:
Segment(pair<long long, long long> a, pair<long long, long long> b) {
x = a;
y = b;
}
private:
long double dotProduct(Vector a, Vector b) {
return a.x.first * b.x.first + a.x.second * b.x.second;
}
private:
long double crossProduct(Vector a, Vector b) {
return a.x.first * b.x.second - a.x.second * b.x.first;
}
private:
long double magnitude(Vector a) { return a.getMagnitude(); }
public:
long double distanceToA(pair<long long, long long> c) {
return dotProduct(Vector(x, y), Vector(x, c)) / magnitude(Vector(x, y));
}
public:
long double distanceToSegment(pair<long long, long long> c) {
if (distanceToA(c) >= 0 && distanceToA(c) <= magnitude(Vector(x, y)))
return crossProduct(Vector(x, y), Vector(x, c)) / magnitude(Vector(x, y));
else
return min(magnitude(Vector(x, c)), magnitude(Vector(y, c)));
}
};
class HopcroftKarp {
vector<int> matched;
vector<vector<pair<int, int> > > adj;
int left;
int right;
public:
HopcroftKarp(vector<vector<pair<int, int> > > inp, int l, int r) {
adj = inp;
left = l;
matched.resize(l);
for (int i = 0; i < l; i++) matched[i] = -1;
right = r;
}
public:
vector<int> match() {
bool cont = true;
set<int> lfree, rfree;
for (int i = 0; i < left; i++) lfree.insert(i);
for (int i = left; i < left + right; i++) rfree.insert(i);
vector<bool> yet(left, 0);
for (int i = 0; i < left; i++)
for (int j = 0; j < adj[i].size(); j++)
if (adj[i][j].second == 1 && rfree.count(adj[i][j].first) && !yet[i]) {
yet[i] = true;
matched[i] = adj[i][j].first;
adj[i][j].second = 2;
for (int x = 0; x < adj[adj[i][j].first].size(); x++)
if (adj[adj[i][j].first][x].first == i)
adj[adj[i][j].first][x].second = 2;
rfree.erase(adj[i][j].first);
lfree.erase(i);
}
while (cont) {
vector<int> par(left + right, -1);
queue<pair<int, int> > kyou;
for (int z : lfree) kyou.push(make_pair(z, 0));
int update = -1;
vector<int> vis(left + right, 0);
while (kyou.size()) {
pair<int, int> frt = kyou.front();
kyou.pop();
if (rfree.count(frt.first)) {
update = frt.first;
break;
}
if (frt.second == 0) {
for (pair<int, int> z : adj[frt.first]) {
if (z.second == 1 && !vis[z.first]) {
par[z.first] = frt.first;
vis[z.first] = 1;
kyou.push(make_pair(z.first, 1));
}
}
} else {
for (pair<int, int> z : adj[frt.first]) {
if (z.second == 2 && !vis[z.first]) {
par[z.first] = frt.first;
vis[z.first] = 1;
kyou.push(make_pair(z.first, 0));
}
}
}
}
int x = update;
int cnt = 0;
while (x != -1 && par[x] != -1) {
for (int i = 0; i < adj[x].size(); i++)
if (adj[x][i].first == par[x]) {
adj[x][i].second = (cnt == 0 ? 2 : 1);
if (cnt == 0) {
matched[par[x]] = x;
rfree.erase(x);
lfree.erase(par[x]);
}
}
for (int i = 0; i < adj[par[x]].size(); i++)
if (adj[par[x]][i].first == x)
adj[par[x]][i].second = (cnt == 0 ? 2 : 1);
cnt++;
cnt %= 2;
x = par[x];
}
if (update == -1) cont = false;
}
return matched;
}
};
class Triangle {
pair<long long, long long> x, y, z;
public:
Triangle(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
x = a;
y = b;
z = c;
}
private:
long double crossProduct(Vector a, Vector b) {
return a.x.first * b.x.second - a.x.second * b.x.first;
}
public:
long double perimeter() {
long double s1, s2, s3;
s1 = Vector(x, y).getMagnitude();
s2 = Vector(y, z).getMagnitude();
s3 = Vector(x, z).getMagnitude();
return s1 + s2 + s3;
}
public:
long double area() { return abs(crossProduct(Vector(x, y), Vector(x, z))); }
};
class SuffixArray {
vector<int> order;
vector<int> lcp;
string str;
public:
SuffixArray(string in) {
str = in;
str += '$';
order.resize(str.length());
lcp.resize(str.length());
compute();
}
void compute() {
vector<pair<char, int> > a;
vector<int> equi(order.size());
vector<int> bij(order.size());
for (int i = 0; i < str.length(); i++) a.push_back(make_pair(str[i], i));
sort(a.begin(), a.end());
for (int i = 0; i < str.length(); i++) order[i] = a[i].second;
equi[order[0]] = 0;
int r = 0;
for (int i = 1; i < str.length(); i++) {
if (a[i].first == a[i - 1].first)
equi[order[i]] = r;
else
equi[order[i]] = ++r;
}
int k = 0;
while ((1 << k) < str.length()) {
vector<pair<pair<int, int>, int> > a(str.length());
for (int i = 0; i < str.length(); i++)
a[i] = make_pair(
make_pair(equi[i], equi[(i + (1 << k)) % (str.length())]), i);
sort(a.begin(), a.end());
for (int i = 0; i < str.length(); i++) {
order[i] = a[i].second;
bij[order[i]] = i;
}
int r = 0;
equi[order[0]] = 0;
for (int i = 1; i < str.length(); i++) {
if (a[i].first == a[i - 1].first)
equi[order[i]] = r;
else
equi[order[i]] = ++r;
}
k++;
}
k = 0;
for (int i = 0; i < str.length() - 1; i++) {
int p = bij[i];
int j = order[p - 1];
while (i + k < str.length() && j + k < str.length() &&
str[i + k] == str[j + k])
k++;
lcp[p] = k;
k = max(k - 1, 0);
}
}
public:
int count(string ptr) {
int low = 0;
int hi = str.length() - 1;
int res1, res2;
res1 = 0;
res2 = 1e9;
while (low <= hi) {
int mid = (low + hi) / 2;
bool gr = false;
int i = 0;
for (i; i < min(ptr.length(), str.length() - order[mid]); i++) {
if (ptr[i] != str[order[mid] + i]) {
if (ptr[i] > str[order[mid] + i]) gr = true;
break;
}
}
if (i == ptr.length()) {
res2 = min(res2, mid);
hi = mid - 1;
} else if (!gr)
hi = mid - 1;
else
low = mid + 1;
}
low = 0;
hi = str.length() - 1;
while (low <= hi) {
int mid = (low + hi) / 2;
bool gr = false;
int i = 0;
for (i; i < min(ptr.length(), str.length() - order[mid] + 1); i++) {
if (ptr[i] != str[order[mid] + i]) {
if (ptr[i] > str[order[mid] + i]) gr = true;
break;
}
}
if (i == ptr.length()) {
res1 = max(res1, mid);
low = mid + 1;
} else if (!gr)
hi = mid - 1;
else
low = mid + 1;
}
if (res2 == 1e9) return 0;
return (res1 - res2 + 1);
}
public:
vector<int> get() { return order; }
public:
vector<int> getLcp() { return lcp; }
public:
long long diffSubstrings() {
long long out = 0;
for (int i = 1; i < str.length(); i++)
out += str.length() - order[i] - lcp[i] - 1;
return out;
}
};
string longestCommonSubstring(string a, string b) {
int len = 0;
string res = a + '%' + b;
SuffixArray sf = SuffixArray(res);
vector<int> order = sf.get();
vector<int> lcp = sf.getLcp();
vector<int> col(order.size());
for (int i = 0; i < order.size(); i++) {
if (order[i] < a.length())
col[order[i]] = 1;
else if (order[i] > a.length())
col[order[i]] = 2;
}
int pos = -1;
for (int i = 1; i < order.size(); i++)
if (col[order[i]] + col[order[i - 1]] == 3) {
if (lcp[i] > len) {
len = max(len, lcp[i]);
pos = (col[order[i]] == 1 ? order[i] : order[i - 1]);
}
}
return a.substr(pos, len);
}
void solve() {
int n, k;
cin >> n >> k;
vector<int> all(n);
vector<int> bij(n + 1);
set<int> st;
for (int i = 0; i < n; i++) {
cin >> all[i];
bij[all[i]] = i;
st.insert(i);
}
set<int> b;
vector<int> bb(k);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
bb[i] = x;
b.insert(x);
}
long long ans = 1;
for (int i = 0; i < k; i++) {
int pos = bij[bb[i]];
auto t = st.find(pos);
auto m = t;
m++;
if (t == st.begin()) {
auto r = t;
r++;
if (b.count(all[*r])) {
cout << 0 << '\n';
return;
} else {
st.erase(*r);
}
} else if (m == st.end()) {
auto r = t;
r--;
if (b.count(all[*r])) {
cout << 0 << '\n';
return;
} else
st.erase(*r);
} else {
auto r = t;
auto q = t;
r++;
q--;
if (!b.count(all[*r]) && !b.count(all[*q])) {
ans *= 2;
ans %= mod;
st.erase(*r);
} else if (!b.count(all[*r]))
st.erase(*r);
else if (!b.count(all[*q]))
st.erase(*q);
else {
cout << 0 << '\n';
return;
}
}
b.erase(bb[i]);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> st;
int s_find(int r) { return st[r] == r ? r : st[r] = s_find(st[r]); }
void s_union(int a, int b) {
int sa = s_find(a);
int sb = s_find(b);
st[sa] = sb;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<array<int, 3>> e;
for (int i = 0; i < m; ++i) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
--a;
--b;
e.push_back({w, a, b});
}
sort(e.begin(), e.end());
for (int i = 0; i < n; ++i) st.push_back(i);
int cnt = 0, i = 0;
while (i < m) {
int j = i;
while (i < m && e[j][0] == e[i][0]) i++;
for (int k = j; k < i; ++k) cnt += s_find(e[k][1]) != s_find(e[k][2]);
for (int k = j; k < i; ++k) s_union(e[k][1], e[k][2]);
}
printf("%d\n", cnt - n + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace RA {
int r(int p) { return 1ll * rand() * rand() % p; }
int r(int L, int R) { return r(R - L + 1) + L; }
} // namespace RA
const int SZ = 1 << 19, P = 998244353;
int pw(int a, int m) {
if (m < 0) m += P - 1;
int res = 1;
while (m) m & 1 ? res = 1ll * res * a % P : 0, a = 1ll * a * a % P, m >>= 1;
return res;
}
int tr[SZ];
int init(int n) {
int len = 1;
while (len < n) len <<= 1;
for (int i = (0); i <= (len - 1); ++i)
tr[i] = tr[i >> 1] >> 1 | ((i & 1) * (len / 2));
return len;
}
void dft(int *f, int len, int tag) {
for (int i = (0); i <= (len - 1); ++i)
if (i < tr[i]) swap(f[i], f[tr[i]]);
for (int i = (0); i <= (len - 1); ++i) f[i] = (f[i] + P) % P;
for (int j = 1; j < len; j <<= 1)
for (int i = 0, wn = pw(3, (P - 1) / (j << 1) * tag); i < len; i += j << 1)
for (int k = i, u, v, w = 1; k < i + j; k++, w = 1ll * w * wn % P)
u = f[k], v = f[k + j] * 1ll * w % P, f[k] = (u + v) % P,
f[k + j] = (u - v + P) % P;
if (tag == -1)
for (int i = 0, ilen = pw(len, P - 2); i < len; i++)
f[i] = 1ll * f[i] * ilen % P;
}
int inv_h[SZ];
void inv(int *f, int *g, int n) {
if (n == 1) return g[0] = pw(f[0], P - 2), void();
inv(f, g, (n + 1) / 2);
int len = init(2 * (n));
for (int i = (0); i <= (len - 1); ++i) inv_h[i] = 0;
for (int i = ((n + 1) / 2); i <= (len - 1); ++i) g[i] = 0;
for (int i = (0); i <= (n - 1); ++i) inv_h[i] = f[i];
dft(inv_h, len, 1), dft(g, len, 1);
for (int i = (0); i <= (len - 1); ++i)
inv_h[i] = 1ll * inv_h[i] * g[i] % P * g[i] % P;
dft(g, len, -1), dft(inv_h, len, -1);
for (int i = (0); i <= (n - 1); ++i) g[i] = (g[i] * 2ll - inv_h[i] + P) % P;
for (int i = (n); i <= (len - 1); ++i) g[i] = 0;
}
int ln_h[SZ];
void ln(int *f, int *g, int n) {
inv(f, g, n);
int len = init(n * 2);
for (int i = (n); i <= (len - 1); ++i) ln_h[i] = g[i] = 0;
ln_h[n - 1] = 0;
for (int i = (1); i <= (n - 1); ++i) ln_h[i - 1] = f[i] * 1ll * i % P;
dft(ln_h, len, 1), dft(g, len, 1);
for (int i = (0); i <= (len - 1); ++i) g[i] = 1ll * g[i] * ln_h[i] % P;
dft(g, len, -1);
for (int i = (n - 1); i >= (1); --i) g[i] = g[i - 1] * 1ll * pw(i, P - 2) % P;
g[0] = 0;
}
int t2[SZ], h2[SZ];
void exp(int *f, int *g, int n) {
if (n == 1) return g[0] = 1, void();
exp(f, g, (n + 1) / 2);
for (int i = ((n + 1) / 2); i <= (n - 1); ++i) g[i] = 0;
ln(g, h2, n);
for (int i = (0); i <= (n - 1); ++i) t2[i] = (f[i] - h2[i] + P) % P;
t2[0] = (t2[0] + 1) % P;
int len = init(n * 2);
for (int i = (n); i <= (len); ++i) g[i] = t2[i] = 0;
dft(g, len, 1), dft(t2, len, 1);
for (int i = (0); i <= (len - 1); ++i) g[i] = g[i] * 1ll * t2[i] % P;
dft(g, len, -1);
}
int n, m;
int g[SZ], g2[SZ];
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) {
int c;
scanf("%d", &c);
g[c] = 1;
}
for (int i = (0); i <= (m); ++i) g[i] *= -4;
g[0]++;
assert(g[0] == 1);
ln(g, g2, m + 1);
for (int i = (0); i <= (m); ++i) g2[i] = g2[i] * 1ll * ((P + 1) / 2) % P;
exp(g2, g, m + 1);
g[0]++;
inv(g, g2, m + 1);
for (int i = (0); i <= (m); ++i) g2[i] = g2[i] * 2ll % P;
for (int i = (1); i <= (m); ++i) printf("%d\n", g2[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void _do(T x) {
cerr << x << "\n";
}
template <typename T, typename... U>
void _do(T x, U... y) {
cerr << x << ", ";
_do(y...);
}
struct ope {
int id, x, y;
};
int n, k, cnt;
int arr[5][55], vis[5][55];
pair<int, int> park[105];
pair<int, int> d[] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
vector<ope> v, stk;
bool dfs(int id, pair<int, int> cur, pair<int, int> aim) {
vis[cur.first][cur.second] = 1;
for (int i = 0; i < 4; i++) {
if (cur + d[i] == aim) {
stk.push_back({id, aim.first, aim.second});
return 1;
}
}
for (int i = 0; i < 4; i++) {
pair<int, int> nxt = cur + d[i];
if (nxt.first >= 2 && nxt.first <= 3 && nxt.second >= 1 &&
nxt.second <= n && arr[nxt.first][nxt.second] == 0 &&
!vis[nxt.first][nxt.second]) {
if (dfs(id, nxt, aim)) {
stk.push_back({id, nxt.first, nxt.second});
return 1;
}
}
}
return 0;
}
bool direct_move() {
bool ok = 0;
for (int i = 2; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
if (arr[i][j]) {
memset(vis, 0, sizeof(vis));
if (dfs(arr[i][j], {i, j}, park[arr[i][j]])) {
arr[i][j] = 0;
++cnt;
ok = 1;
reverse((stk).begin(), (stk).end());
for (auto &i : stk) v.push_back(i);
}
stk.clear();
}
}
}
return ok;
}
bool iddfs(pair<int, int> cur, int step) {
if (step < 0) return 0;
if (arr[cur.first][cur.second] == 0) return 1;
vis[cur.first][cur.second] = 1;
for (int i = 0; i < 4; i++) {
pair<int, int> nxt = cur + d[i];
if (nxt.first >= 2 && nxt.first <= 3 && nxt.second >= 1 &&
nxt.second <= n && !vis[nxt.first][nxt.second]) {
if (iddfs(nxt, step - 1)) {
stk.push_back({arr[cur.first][cur.second], nxt.first, nxt.second});
swap(arr[cur.first][cur.second], arr[nxt.first][nxt.second]);
return 1;
}
}
}
return 0;
}
void mv(pair<int, int> cur, int dir) {
memset(vis, 0, sizeof(vis));
vis[cur.first][cur.second] = 1;
stk.clear();
pair<int, int> to = cur + d[dir];
bool ok = iddfs(to, 5);
assert(ok);
stk.push_back({arr[cur.first][cur.second], to.first, to.second});
swap(arr[cur.first][cur.second], arr[to.first][to.second]);
for (auto i : stk) v.push_back(i);
stk.clear();
}
void bf_move(int cx, int cy, int id) {
assert(id);
auto &[ax, ay] = park[id];
int mx = ax - cx, my = ay - cy;
if (mx > 0)
for (int i = 0; i < mx - 1; i++) mv({cx, cy}, 0), cx++;
if (mx < 0)
for (int i = 0; i < -mx - 1; i++) mv({cx, cy}, 1), cx--;
if (my > 0)
for (int i = 0; i < my; i++) mv({cx, cy}, 2), cy++;
if (my < 0)
for (int i = 0; i < -my; i++) mv({cx, cy}, 3), cy--;
v.push_back({id, park[id].first, park[id].second});
arr[cx][cy] = 0;
++cnt;
}
signed main() {
cin >> n >> k;
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
cin >> arr[i][j];
if ((i == 1 || i == 4) && arr[i][j]) park[arr[i][j]] = {i, j};
}
}
if (k == 2 * n && !direct_move()) return cout << -1 << '\n', 0;
while (cnt < k) {
while (direct_move())
;
for (int j = 1; j < n; j++)
if (arr[2][j] == 0 && arr[2][j + 1] != 0)
bf_move(2, j + 1, arr[2][j + 1]);
for (int j = 1; j < n; j++)
if (arr[2][j + 1] == 0 && arr[2][j] != 0) bf_move(2, j, arr[2][j]);
for (int j = 1; j < n; j++)
if (arr[3][j] == 0 && arr[3][j + 1] != 0)
bf_move(3, j + 1, arr[3][j + 1]);
for (int j = 1; j < n; j++)
if (arr[3][j + 1] == 0 && arr[3][j] != 0) bf_move(3, j, arr[3][j]);
for (int j = 1; j <= n; j++)
if (arr[2][j] == 0 && arr[3][j] != 0) bf_move(3, j, arr[3][j]);
for (int j = 1; j <= n; j++)
if (arr[3][j] == 0 && arr[2][j] != 0) bf_move(2, j, arr[2][j]);
}
assert(v.size() <= 20000);
cout << v.size() << '\n';
for (auto i : v) {
cout << i.id << " " << i.x << " " << i.y << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, M = 0;
scanf("%d%d", &N, &K);
static int A[100000];
for (int i = 0; i < N; i++) {
int X;
scanf("%d", &X);
X--;
if (!M || X != A[M - 1]) A[M++] = X;
}
static int Count[100000];
for (int i = 0; i < M; i++) Count[A[i]]++;
for (int i = 1; i + 1 < M; i++)
if (A[i - 1] == A[i + 1]) Count[A[i]]++;
int Ans = 0;
for (int i = 1; i < K; i++)
if (Count[i] > Count[Ans]) Ans = i;
printf("%d\n", Ans + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long minimum(long long a1, long long a2, long long a3, long long b1,
long long b2, long long b3);
long long maximum(long long a1, long long a2, long long a3, long long b1,
long long b2, long long b3);
long long min(long long a, long long b);
long long min(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
long long minimum(long long a1, long long a2, long long a3, long long b1,
long long b2, long long b3) {
long long count = 0;
a1 -= min(a1, b1);
a1 -= min(a1, b3);
a3 -= min(a3, b3);
a3 -= min(a3, b2);
a2 -= min(a2, b2);
a2 -= min(a2, b1);
count = a1 + a2 + a3;
return count;
}
long long maximum(long long a1, long long a2, long long a3, long long b1,
long long b2, long long b3) {
long long count = 0;
count = min(a1, b2) + min(a2, b3) + min(a3, b1);
return count;
}
int main() {
long long n, a1, a2, a3, b1, b2, b3, max, min;
scanf("%lld", &n);
scanf("%lld %lld %lld", &a1, &a2, &a3);
scanf("%lld %lld %lld", &b1, &b2, &b3);
min = minimum(a1, a2, a3, b1, b2, b3);
max = maximum(a1, a2, a3, b1, b2, b3);
printf("%lld %lld", min, max);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 3e9;
const long long N = 1e5 + 1;
const long long mod = 1e9 + 7;
const long double eps = 1E-7;
int n, k;
set<int> s;
int p, a[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
while (n) {
s.insert(a[n]);
if (s.size() != 1) break;
n--;
}
if (n < k)
cout << n;
else
cout << -1;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T, typename TT>
inline ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T>
inline istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &is, pair<T1, T2> &t) {
is >> t.first >> t.second;
return is;
}
const long long mod = 1e9 + 7;
void solve() {
long long n;
cin >> n;
vector<long long> ans(2 * n, n);
long long dif = n - 1, i = 0, j = n;
for (int k = 1; k < n; k++, dif--) {
if (k & 1)
ans[i] = k, ans[i + dif] = k, i++;
else
ans[j] = k, ans[j + dif] = k, j++;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
long long T = 1;
while (T--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int INF = 1000000000 + 1e8;
const long long LINF = 8000000000000000000;
long long gcd(long long a, long long b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
void solve() {
int n;
cin >> n;
long long chet_gcd, nechet_gcd;
cin >> chet_gcd >> nechet_gcd;
vector<long long> arr(n);
arr[0] = chet_gcd;
arr[1] = nechet_gcd;
for (int i = 2; i < n; i++) {
long long a;
cin >> a;
arr[i] = a;
if (i % 2 == 0) {
long long gc = gcd(chet_gcd, a);
chet_gcd = gc;
} else {
long long gc = gcd(nechet_gcd, a);
nechet_gcd = gc;
}
}
bool flag = true;
for (int i = 1; i < n; i += 2) {
if (arr[i] % chet_gcd == 0) {
flag = false;
break;
}
}
if (flag) {
cout << chet_gcd << '\n';
return;
}
flag = true;
for (int i = 0; i < n; i += 2) {
if (arr[i] % nechet_gcd == 0) {
flag = false;
break;
}
}
if (flag) {
cout << nechet_gcd << '\n';
return;
} else
cout << 0 << '\n';
}
int main() {
srand(time(0));
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tst = 1;
cin >> tst;
while (tst--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int val[2002];
long long int dp[2002][2002];
bool use[2002][2002];
int bit[2002];
void add(int i, int x) {
i++;
while (i < 2002) {
bit[i] += x;
i += i & -i;
}
}
int sum(int i) {
int r = 0;
i++;
while (i) {
r += bit[i];
i -= i & -i;
}
return r;
}
int rng(int i, int j) {
int S = sum(j);
if (i) {
S -= sum(i - 1);
}
return S;
}
vector<int> v;
inline long long int dfs(int a, int b, int nega) {
if (a == n) {
return 0;
}
if (a && val[v[a]] != val[v[a - 1]]) {
b = nega = 0;
}
if (use[a][b]) {
return dp[a][b];
}
if (b == 0 && nega == 0) {
int id = a;
while (id < v.size() && val[v[a]] == val[v[id]]) {
add(v[id], -1);
id++;
}
}
use[a][b] = true;
{
long long int inv = rng(0, v[a]);
inv += dfs(a + 1, b, nega + 1);
dp[a][b] = inv;
}
{
long long int inv = rng(v[a], n - 1);
inv += nega;
inv += dfs(a + 1, b + 1, nega);
dp[a][b] = min(dp[a][b], inv);
}
if (b == 0 && nega == 0) {
int id = a;
while (id < v.size() && val[v[a]] == val[v[id]]) {
add(v[id], 1);
id++;
}
}
return dp[a][b];
}
bool cmp(int a, int b) { return make_pair(val[a], a) > make_pair(val[b], b); }
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &val[i]);
val[i] = abs(val[i]);
v.push_back(i);
add(i, 1);
}
sort(v.begin(), v.end(), cmp);
long long int ans = dfs(0, 0, 0);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int sum = 0;
int s[100000];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
if (s[i] != s[i + 1]) sum += 1;
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
int n, m, w[N], head[N], nxt[N];
vector<int> e[N];
set<int> S[N];
void add(int f, int t) {
static int cnt = 0;
w[++cnt] = t;
nxt[cnt] = head[f];
head[f] = cnt;
S[f].insert(t);
}
int size, q[N][3];
void print(int x, int y, int z) {
size++;
q[size][0] = x;
q[size][1] = y;
q[size][2] = z;
}
bool vis[N];
void dfs(int x, int fa) {
vis[x] = 1;
for (int i = head[x]; i; i = nxt[i]) {
S[x].erase(w[i]);
if (!vis[w[i]])
dfs(w[i], x);
else if (S[w[i]].count(x))
e[x].push_back(w[i]);
}
for (int i = 1; i < e[x].size(); i += 2) print(e[x][i - 1], x, e[x][i]);
if (!fa) return;
if (e[x].size() & 1)
print(fa, x, e[x][e[x].size() - 1]);
else
e[fa].push_back(x);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i, 0);
printf("%d\n", size);
for (int i = 1; i <= size; i++)
printf("%d %d %d\n", q[i][0], q[i][1], q[i][2]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next;
} edges[1111 * 2];
int head[1111];
void addedge(int from, int to, int no) {
edges[no].to = to;
edges[no].next = head[from];
head[from] = no;
}
int ans;
int leaf[1111];
void sol(int o, int fa) {
int cnt = 0;
for (int i = head[o]; ~i; i = edges[i].next) {
int to = edges[i].to;
if (to != fa) cnt++;
}
if (!cnt) {
leaf[o] = 1;
return;
}
cnt = 0;
for (int i = head[o]; ~i; i = edges[i].next) {
int to = edges[i].to;
if (to == fa) continue;
sol(to, o);
if (leaf[to]) cnt++;
}
if (cnt < 3) ans = 0;
}
int main() {
int n;
cin >> n;
memset(head, -1, sizeof(head));
for (int i = 2; i <= n; i++) {
int a;
cin >> a;
addedge(i, a, i << 1);
addedge(a, i, i << 1 | 1);
}
ans = 1;
sol(1, -1);
if (ans)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string input;
cin >> input;
int n = input.size();
vector<int> arr(n + 1), best(n + 1);
for (int i = 0; i < n; ++i) {
char c = tolower(input[i]);
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
arr[i + 1] = -1;
else
arr[i + 1] = 2;
}
int len = 0, times = 0, sum = 0;
for (int i = 1; i <= n; ++i) {
sum += arr[i];
best[i] = max(best[i - 1], -sum);
int lo = 0, hi = i, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (best[mid] + sum >= 0)
hi = mid;
else
lo = mid + 1;
}
int cur_len = i - lo;
if (cur_len > len) {
len = cur_len;
times = 0;
}
if (cur_len == len) ++times;
}
if (len == 0) {
cout << "No solution\n";
} else {
cout << len << ' ' << times << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long int n, k;
cin >> n >> k;
long long int x = n / 2;
long long int ans;
if (n % 2 != 0) x++;
if (k > x) {
k -= x;
ans = 2 * k;
} else {
ans = 2 * (k - 1) + 1;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int MAX = 512;
int n;
int m;
vector<int> ra, rb;
int g[MAX][MAX], w[MAX], d[MAX][MAX], p[MAX][MAX];
int q[250000];
int out(int a, int b) {
ra.push_back(a + 1);
rb.push_back(b + 1);
if (d[a][b] == 1) return 0;
out(p[a][b] >> 10, p[a][b] & 1023);
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
g[a][w[a]++] = b;
g[b][w[b]++] = a;
}
int l = 0, r = 1;
q[0] = n - 1;
memset(d, 0, sizeof(d));
d[0][n - 1] = 1;
int a, b, c, e;
while (l < r) {
a = q[l] >> 10;
b = q[l] & 1023;
int D = d[a][b] + 1, P = (a << 10) + b;
if (a == n - 1 && b == 0) break;
l++;
int *I = &g[a][0], *J = &g[b][0], *i, *j;
int *II = I + w[a], *JJ = J + w[b];
for (i = I; i != II; i++)
for (j = J; j != JJ; j++) {
c = *i;
e = *j;
if (c != e && !d[c][e]) {
d[c][e] = D;
p[c][e] = P;
q[r++] = (c << 10) + e;
}
}
}
if (!d[n - 1][0]) {
printf("-1\n");
return 0;
}
printf("%d\n", d[n - 1][0] - 1);
out(n - 1, 0);
reverse((ra).begin(), (ra).end());
reverse((rb).begin(), (rb).end());
for (int i = 0; i < ra.size(); i++) printf("%d ", ra[i]);
printf("\n");
for (int i = 0; i < rb.size(); i++) printf("%d ", rb[i]);
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int mx = 1e9;
const int v4i[4] = {0, 0, -1, 1};
const int v4j[4] = {-1, 1, 0, 0};
const int v8i[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
const int v8j[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
int n;
string s, t[6];
int dis(string a, string b) {
int ans = 0;
for (int i = 0; i < n; i++)
if (a[i] != b[i]) ans++;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
for (int i = 0; i <= n / 3; i++) {
t[0] += "RGB";
t[1] += "RBG";
t[2] += "BRG";
t[3] += "BGR";
t[4] += "GRB";
t[5] += "GBR";
}
int m = inf, id = -1;
for (int i = 0; i < 6; i++)
if (dis(t[i], s) < m) m = dis(t[i], s), id = i;
cout << m << endl << t[id].substr(0, n);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
vector<vector<char> > vvc;
string s;
while (getline(cin, s)) {
vector<char> vv;
for (int i = 0; i < s.size(); i++) vv.push_back(s[i]);
vvc.push_back(vv);
}
vector<bool> amp(vvc.size() + 1, 0);
for (int i = 0; i < vvc.size(); i++) {
int ind = 0;
while (ind < vvc[i].size() && vvc[i][ind] == ' ') ind++;
if (vvc[i].size() && vvc[i][ind] == '#') amp[i] = true;
}
for (int i = 0; i < vvc.size(); i++) {
if (amp[i]) {
for (int j = 0; j < vvc[i].size(); j++) putchar(vvc[i][j]);
putchar(10);
} else {
for (int j = 0; j < vvc[i].size(); j++)
if (vvc[i][j] != ' ') putchar(vvc[i][j]);
if (amp[i + 1]) {
putchar(10);
}
}
}
if (!amp[vvc.size() - 1]) putchar(10);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y;
cin >> x >> y;
if ((x > 0) && (y > 0)) {
cout << 0 << ' ' << (x + y) << ' ' << (x + y) << ' ' << 0 << endl;
} else {
if ((x < 0) && (y > 0)) {
cout << (x - y) << ' ' << 0 << ' ' << 0 << ' ' << (y - x) << endl;
} else {
if ((x < 0) && (y < 0)) {
cout << (x + y) << ' ' << 0 << ' ' << 0 << ' ' << (y + x) << endl;
} else if ((x > 0) && (y < 0)) {
cout << 0 << ' ' << (-x + y) << ' ' << (x - y) << ' ' << 0 << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
vector<pair<long long, long long> > V;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, a, b;
cin >> n >> a >> b;
long long c = 0;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
if (x == 2) {
if (b)
b--;
else
ans += 2;
} else {
if (a)
a--;
else if (b)
b--, c++;
else if (c)
c--;
else
ans++;
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100001], t[100001], aux[100001], h[100001];
int n, i = -1, j = 0;
ios::sync_with_stdio(0);
scanf("%s %s", s, t);
n = strlen(s);
while (i < n) {
if (s[i] != t[i]) {
if (j % 2 == 0) {
h[i] = s[i];
++j;
} else {
h[i] = t[i];
j++;
}
i++;
} else {
h[i] = s[i];
i++;
}
}
if (j % 2 != 0) {
cout << "impossible";
} else {
for (int i = 0; i < n; i++) cout << h[i];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, sum, s[200005], f[200005], g[200005], flag[200005], k = 1, la[200005],
ff[200005 * 2];
struct node {
int a, b;
} e[200005 * 2];
void add(int a, int b) {
e[++k] = (node){a, b};
ff[k] = la[a];
la[a] = k;
e[++k] = (node){b, a};
ff[k] = la[b];
la[b] = k;
}
void dfs(int x) {
flag[x] = 1;
g[x] = s[x];
for (int a = la[x]; a; a = ff[a]) {
if (flag[e[a].b]) continue;
dfs(e[a].b);
g[x] += g[e[a].b];
if (a & 1)
f[a >> 1] = -g[e[a].b];
else
f[a >> 1] = g[e[a].b];
}
}
int main() {
int a, b;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]), sum += s[i];
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &a, &b), add(a, b);
if (sum) {
printf("Impossible\n");
return 0;
}
for (int i = 1; i <= n; i++)
if (!flag[i]) dfs(i);
printf("Possible\n");
for (int i = 1; i <= m; i++) printf("%d\n", f[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
int n, q;
long long int B;
int ar[2000005];
long long int sum[2000005];
int nxt[2000005], back[2000005];
int solve() {
if (sum[n] <= B) return 1;
int j = 0;
for (int i = 0; i < (n); ++i) {
while (j < n * 2 && sum[j + 1] - sum[i] <= B) ++j;
nxt[i] = j;
}
j = n * 2 - 1;
for (int i = n * 2 - 1; i >= n; --i) {
while (j >= 0 && sum[i] - sum[j - 1] <= B) --j;
back[i - n] = j % n;
}
int cur = 0, cnt = 0;
while (cur < n) cur = nxt[cur], ++cnt;
int pos = cur % n;
cur %= n;
for (int hoge = 0; hoge < (cnt - 1); ++hoge) cur = back[cur];
if (cur <= pos) return cnt - 1;
return cnt;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < (n); ++i) scanf("%d", &ar[i]);
for (int i = 0; i < (n); ++i) ar[i + n] = ar[i];
for (int i = 0; i < (n * 2); ++i) sum[i + 1] = sum[i] + ar[i];
for (int hoge = 0; hoge < (q); ++hoge) {
B = readL();
printf("%d\n", solve());
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.