solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
istream& operator>>(istream& ss, vector<T>& v) {
for (int i = 0; i < v.size(); i++) ss >> v[i];
return ss;
}
template <class T>
ostream& operator<<(ostream& ss, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) ss << v[i] << ' ';
return ss;
}
long long binpow(long long a, long long n, long long m) {
long long res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= m;
}
a *= (a % m);
a %= m;
n >>= 1;
}
return res % m;
}
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 get(long long n) { return n * (n + 1) / 2; }
const int mod = 1e9 + 7;
const int inf = 1e9;
const int N = 2e5 + 5;
void solve() {
int n, k;
cin >> n >> k;
vector<int> a(n);
cin >> a;
if (k == 1) {
for (int i = 1; i < n; ++i) {
if (a[i] != a[i - 1]) {
cout << -1 << endl;
return;
}
}
cout << 1 << endl;
return;
}
set<int> s;
int cnt = 0;
for (int i = 0; i < n; ++i) {
s.insert(a[i]);
if (s.size() > k) {
cnt++;
s = set<int>();
s.insert(a[i]);
s.insert(0);
}
}
cout << cnt + 1 << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int pp;
cin >> pp;
for (int jiaran = 1; jiaran <= pp; jiaran++) {
int left, right, t = 1;
cin >> left >> right;
int p1 = 1, p2 = 2, temp = 0, p;
int l, r, k1, k2, k;
while (p2 <= right * 2) {
p = 0;
l = left / p1 + (left % p1 > 0);
r = right / p1;
if (r >= l) {
p = (r - l);
p /= 2;
if (l % 2 > 0 && r % 2 == 0) p++;
p *= p1;
if (l % 2 == 0) p += l * p1 - left;
if (r % 2 != 0) p += right - r * p1 + 1;
} else {
if (r % 2 > 0) p = right - left + 1;
}
if (p > temp) {
temp = p;
}
p1 *= 2;
p2 *= 2;
}
cout << right - left + 1 - temp << endl << endl;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
inline int rei() {
int x;
cin >> x;
return x;
}
inline long long rel() {
long long x;
cin >> x;
return x;
}
inline string res() {
string x;
cin >> x;
return x;
}
long long Pow(long long X, long long R) {
if (R == 0) {
return 1;
}
if (R % 2 == 0) {
long long T = Pow(X, R / 2);
return T * T % 1000003;
}
return X * Pow(X, R - 1) % 1000003;
}
class LMOD {
public:
using t = long long;
static t id() { return 0; }
static t e() { return 1; }
static t Prod(const t& l, const t& r) { return l * r % 1000003; }
static t Plus(const t& l, const t& r) { return (l + r) % 1000003; }
static t Minus(const t& x) { return (1000003 - x) % 1000003; }
static t Divide(const t& x) { return Pow(x, 1000003 - 2); }
static bool Smaller(const t& x, const t& y) { return x <= y; }
};
template <typename M>
struct Matrix {
using T = typename M::t;
int H;
int W;
vector<T> data;
vector<T> L;
vector<T> U;
vector<int> S;
Matrix(int n_) : H(n_), W(n_), data(n_ * n_, M::id()) {}
Matrix(int h_, int w_) : H(h_), W(w_), data(h_ * w_, M::id()) {}
Matrix(int n_, vector<T> d_) : H(n_), W(n_) { data = d_; }
Matrix(int h_, int w_, vector<T> d_) : H(h_), W(w_) { data = d_; }
void Update(int h, int w, T x) { data[h * W + w] = x; }
const T Get(int h, int w) { return data[h * W + w]; }
Matrix RowNormal() {
vector<T> A(H * W);
for (int i = 0; i < H * W; i++) {
A[i] = data[i];
}
int rank = 0;
for (int i = 0; i < W; i++) {
int nonzero = rank;
while (nonzero < H && A[nonzero * W + i] == M::id()) {
nonzero++;
}
if (nonzero == H) {
continue;
}
if (nonzero != rank) {
for (int j = i; j < W; j++) {
T temp = A[rank * W + j];
A[rank * W + j] = A[nonzero * W + j];
A[nonzero * W + j] = temp;
}
}
{
T d = M::Divide(A[rank * W + i]);
for (int j = i; j < W; j++) {
A[rank * W + j] = M::Prod(A[rank * W + j], d);
}
}
for (int j = 0; j < H; j++) {
if (j == rank) {
continue;
}
T d = M::Minus(A[j * W + i]);
for (int k = i; k < W; k++) {
A[j * W + k] = M::Plus(A[j * W + k], M::Prod(A[rank * W + k], d));
}
}
rank++;
}
Matrix ans(H, W, A);
return ans;
}
int Rank() {
int ans = 0;
vector<T> A(H * W);
vector<bool> used(H);
for (int i = 0; i < H * W; i++) {
A[i] = data[i];
}
for (int i = 0; i < W; i++) {
int nonzero = 0;
while (nonzero < H && (used[nonzero] || A[nonzero * W + i] == M::id())) {
nonzero++;
}
if (nonzero == H) {
continue;
}
ans++;
used[nonzero] = true;
for (int j = 0; j < H; j++) {
if (used[j]) {
continue;
}
T d = M::Minus(M::Prod(M::Divide(A[nonzero * W + i]), A[j * W + i]));
for (int k = i; k < W; k++) {
A[j * W + k] = M::Plus(A[j * W + k], M::Prod(A[nonzero * W + k], d));
}
}
}
return ans;
}
vector<T> GaussianEliminationO(vector<T> b) {
int ans = 0;
int N = H;
vector<T> A(N * N);
for (int i = 0; i < N * N; i++) {
A[i] = data[i];
}
for (int i = 0; i < N; i++) {
int maxj = i;
for (int j = i + 1; j < N; j++) {
if (M::Smaller(A[maxj * N + i], A[j * N + i])) {
maxj = j;
}
}
if (maxj != i) {
for (int j = i; j < N; j++) {
T temp = A[i * N + j];
A[i * N + j] = A[maxj * N + j];
A[maxj * N + j] = temp;
}
{
T temp = b[i];
b[i] = b[maxj];
b[maxj] = temp;
}
}
{
T d = M::Divide(A[i * N + i]);
for (int j = i; j < N; j++) {
A[i * N + j] = M::Prod(A[i * N + j], d);
}
b[i] = M::Prod(b[i], d);
}
for (int j = 0; j < N; j++) {
if (j == i) {
continue;
}
T d = M::Minus(A[j * N + i]);
for (int k = i; k < W; k++) {
A[j * N + k] = M::Plus(A[j * N + k], M::Prod(A[i * N + k], d));
}
b[j] = M::Plus(b[j], M::Prod(b[i], d));
}
}
return b;
}
vector<T> GaussianElimination(vector<T> b) {
int ans = 0;
int N = H;
vector<T> A(N * N);
for (int i = 0; i < N * N; i++) {
A[i] = data[i];
}
for (int i = 0; i < N; i++) {
int nonzeroj = 0;
for (int j = i; j < N; j++) {
if (A[j * N + i] != M::id()) {
nonzeroj = j;
break;
}
}
if (nonzeroj != i) {
for (int j = i; j < N; j++) {
T temp = A[i * N + j];
A[i * N + j] = A[nonzeroj * N + j];
A[nonzeroj * N + j] = temp;
}
{
T temp = b[i];
b[i] = b[nonzeroj];
b[nonzeroj] = temp;
}
}
{
T d = M::Divide(A[i * N + i]);
for (int j = i; j < N; j++) {
A[i * N + j] = M::Prod(A[i * N + j], d);
}
b[i] = M::Prod(b[i], d);
}
for (int j = 0; j < N; j++) {
if (j == i) {
continue;
}
T d = M::Minus(A[j * N + i]);
for (int k = i; k < W; k++) {
A[j * N + k] = M::Plus(A[j * N + k], M::Prod(A[i * N + k], d));
}
b[j] = M::Plus(b[j], M::Prod(b[i], d));
}
}
return b;
}
static Matrix I(int N) {
Matrix ans(N);
for (int i = 0; i < N; i++) {
ans.Update(i, i, M::e());
}
return ans;
}
static Matrix Plus(Matrix& A, Matrix& B) {
int h = A.H;
int w = A.W;
Matrix ans(h, w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
ans.Update(i, j, M::Plus(A.Get(i, j), B.Get(i, j)));
}
}
return ans;
}
static Matrix Minus(Matrix& A) {
int h = A.H;
int w = A.W;
Matrix ans(h, w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
ans.Update(i, j, M::Minus(A.Get(i, j)));
}
}
return ans;
}
static Matrix Minus(Matrix& A, Matrix& B) {
int h = A.H;
int w = A.W;
Matrix ans(h, w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
ans.Update(i, j, M::Plus(A.Get(i, j), M::Minus(B.Get(i, j))));
}
}
return ans;
}
static Matrix Prod(Matrix& A, Matrix& B) {
int h = A.H;
int w = B.W;
int K = A.W;
Matrix ans(h, w);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
T c = M::id();
for (int k = 0; k < K; k++) {
c = M::Plus(c, M::Prod(A.Get(i, k), B.Get(k, j)));
}
ans.Update(i, j, c);
}
}
return ans;
}
static Matrix Pow(Matrix A, long long r) {
int n = A.H;
vector<T> ans(n * n, M::id());
for (int i = 0; i < n; i++) {
ans[i * n + i] = M::e();
}
vector<T> ans2(n * n);
vector<T> AP = A.data;
vector<T> AP2(n * n);
while (r) {
if (r % 2 == 1) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
T c = M::id();
for (int k = 0; k < n; k++) {
c = M::Plus(c, M::Prod(AP[i * n + k], ans[k * n + j]));
}
ans2[i * n + j] = c;
}
}
swap(ans, ans2);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
T c = M::id();
for (int k = 0; k < n; k++) {
c = M::Plus(c, M::Prod(AP[i * n + k], AP[k * n + j]));
}
AP2[i * n + j] = c;
}
}
swap(AP, AP2);
r /= 2;
}
Matrix answ(n, ans);
return answ;
}
void LUDecompositionO() {
int N = H;
vector<T> A(N * N);
L.resize(N * N);
U.resize(N * N);
S.resize(N);
for (int i = 0; i < N * N; i++) {
A[i] = data[i];
}
for (int i = 0; i < N; i++) {
S[i] = i;
}
for (int i = 0; i < N; i++) {
int maxline = i;
for (int j = i + 1; j < N; j++) {
if (M::Smaller(A[maxline * N + i], A[j * N + i])) {
maxline = j;
}
}
for (int j = 0; j < N; j++) {
T temp = A[maxline * N + j];
A[maxline * N + j] = A[i * N + j];
A[i * N + j] = temp;
temp = L[maxline * N + j];
L[maxline * N + j] = L[i * N + j];
L[i * N + j] = temp;
}
{
int temp = S[maxline];
S[maxline] = S[i];
S[i] = temp;
}
L[i * N + i] = 1;
U[i * N + i] = A[i * N + i];
T aiiinv = M::Divide(A[i * N + i]);
for (int j = i + 1; j < N; j++) {
L[j * N + i] = M::Prod(A[j * N + i], aiiinv);
U[i * N + j] = A[i * N + j];
}
for (int j = i + 1; j < N; j++) {
for (int k = i + 1; k < N; k++) {
A[j * N + k] = M::Plus(A[j * N + k],
M::Minus(M::Prod(L[j * N + i], U[i * N + k])));
}
}
}
}
void LUDecomposition() {
int N = H;
vector<T> A(N * N);
L.resize(N * N);
U.resize(N * N);
S.resize(N);
for (int i = 0; i < N * N; i++) {
A[i] = data[i];
}
for (int i = 0; i < N; i++) {
S[i] = i;
}
for (int i = 0; i < N; i++) {
int nonzeroline = i;
for (int j = i + 1; j < N; j++) {
if (A[j * N + i] != M::id()) {
nonzeroline = j;
}
}
for (int j = 0; j < N; j++) {
T temp = A[nonzeroline * N + j];
A[nonzeroline * N + j] = A[i * N + j];
A[i * N + j] = temp;
temp = L[nonzeroline * N + j];
L[nonzeroline * N + j] = L[i * N + j];
L[i * N + j] = temp;
}
{
int temp = S[nonzeroline];
S[nonzeroline] = S[i];
S[i] = temp;
}
L[i * N + i] = 1;
U[i * N + i] = A[i * N + i];
T aiiinv = M::Divide(A[i * N + i]);
for (int j = i + 1; j < N; j++) {
L[j * N + i] = M::Prod(A[j * N + i], aiiinv);
U[i * N + j] = A[i * N + j];
}
for (int j = i + 1; j < N; j++) {
for (int k = i + 1; k < N; k++) {
A[j * N + k] = M::Plus(A[j * N + k],
M::Minus(M::Prod(L[j * N + i], U[i * N + k])));
}
}
}
}
vector<T> SolvebyLU(vector<T> b) {
int N = H;
vector<T> b2(N);
for (int i = 0; i < N; i++) {
b2[i] = b[S[i]];
}
for (int i = 0; i < N; i++) {
T sum = b2[i];
for (int j = 0; j < i; j++) {
sum = M::Plus(sum, M::Minus(M::Prod(b[j], L[i * N + j])));
}
b[i] = sum;
}
for (int i = N - 1; i >= 0; i--) {
T sum = b[i];
for (int j = i + 1; j < N; j++) {
sum = M::Plus(sum, M::Minus(M::Prod(b2[j], U[i * N + j])));
}
b2[i] = M::Prod(sum, M::Divide(U[i * N + i]));
}
return b2;
}
};
void Calc() {
const int N = 11;
vector<long long> V(N * N);
for (int i = 0; i < N; i++) {
long long c = 1;
for (int j = 0; j < N; j++) {
V[i * N + j] = c;
c *= i;
c %= 1000003;
}
}
Matrix<LMOD> Mat(N, V);
Mat.LUDecomposition();
vector<long long> B(N);
for (int i = 0; i < N; i++) {
cout << "? " << i << endl;
B[i] = rei();
if (B[i] == 0) {
cout << "! " << i << endl;
return;
}
}
vector<long long> X = Mat.SolvebyLU(B);
for (int i = 0; i < 1000003; i++) {
long long c = 0;
long long p = 1;
for (int j = 0; j < N; j++) {
c += X[j] * p % 1000003;
p *= i;
p %= 1000003;
}
c %= 1000003;
if (c == 0) {
cout << "! " << i << endl;
return;
}
}
cout << "! -1" << endl;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0);
Calc();
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int N = 35, M = 1e9 + 7;
int n, a[N], c[N][N], fac[N], dp[N][2][N][N];
int main() {
scanf("%d", &n);
n++;
for (int i = 1; i <= 30; i++) {
a[i] = n % 2;
n /= 2;
}
c[0][0] = fac[0] = 1;
for (int i = 1; i <= 30; i++) {
c[i][0] = 1;
fac[i] = fac[i - 1] * 2;
for (int j = 1; j <= i; j++) c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
dp[30][0][0][0] = 1;
for (int i = 30; i; i--) {
for (int flag = 0; flag < 2; flag++)
for (int x = 0; x <= 30; x++)
for (int y = 0; y <= 30; y++)
if (dp[i][flag][x][y]) {
int to;
if (flag)
to = 1;
else if (a[i] == 0)
to = -1;
else
to = 0;
if (to != -1)
dp[i - 1][to][x + 1][y] =
(dp[i - 1][to][x + 1][y] + dp[i][flag][x][y]) % M;
for (int j = 0; j <= x; j++) {
int to;
if (flag)
to = 1;
else if (j % 2 == 1) {
if (a[i] == 0)
continue;
else
to = 0;
} else {
if (a[i] == 0)
to = 0;
else
to = 1;
}
dp[i - 1][to][x][y] =
(dp[i - 1][to][x][y] +
(long long)c[x][j] * fac[y] % M * dp[i][flag][x][y]) %
M;
}
}
}
int ans = 0;
for (int i = 0; i <= 30; i++)
for (int j = 0; j <= 30; j++) (ans += dp[0][1][i][j]) %= M;
printf("%d\n", ans);
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long n;
cin >> n;
map<char, string> m;
m['0'] = "0000";
m['1'] = "0001";
m['2'] = "0010";
m['3'] = "0011";
m['4'] = "0100";
m['5'] = "0101";
m['6'] = "0110";
m['7'] = "0111";
m['8'] = "1000";
m['9'] = "1001";
m['A'] = "1010";
m['B'] = "1011";
m['C'] = "1100";
m['D'] = "1101";
m['E'] = "1110";
m['F'] = "1111";
char s[n][n];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n / 4; j++) {
char c;
cin >> c;
for (long long k = 0; k < 4; k++) s[i][4 * j + k] = m[c][k];
}
}
long long sum[n + 1][n + 1];
for (long long i = 0; i < n + 1; i++)
for (long long j = 0; j < n + 1; j++) sum[i][j] = 0;
for (long long i = 1; i < n + 1; i++)
for (long long j = 1; j < n + 1; j++) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
if (s[i - 1][j - 1] == '1') sum[i][j]++;
}
vector<long long> f;
for (long long i = 1; i < sqrt(n) + 1; i++) {
if (n % i == 0) {
f.push_back(i);
f.push_back(n / i);
}
}
sort((f).begin(), (f).end());
reverse((f).begin(), (f).end());
long long z = (long long)f.size();
long long ans = 1;
for (long long k = 0; k < z; k++) {
long long len = f[k];
long long x = 1;
for (long long i = len; i <= n; i += len)
for (long long j = len; j <= n; j += len) {
if ((sum[i][j] - sum[i - len][j] - sum[i][j - len] +
sum[i - len][j - len]) %
(len * len))
x = 0;
}
if (x) {
cout << len;
return 0;
}
}
cout << ans;
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10, INF = 1e18, mod = 998244353, m_log = 22, p = 337;
long long binpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 == 1)
return (binpow(a, n - 1) * a) % mod;
else {
long long b = binpow(a, n / 2);
return (b * b) % mod;
}
}
inline void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n - 1; i++) {
long long x = (binpow(10, n - i) * 9 * 2) % mod;
if (i != n - 1) {
x = (x + (9 * 9 * binpow(10, n - i - 1) * (n - i - 1)) % mod) % mod;
}
cout << x << " ";
}
cout << 10 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long q = 1;
while (q--) solve();
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
char a[1111][1111];
int n, m;
inline bool rect(int sx, int sy, int fx, int fy) {
for (int i = sx; i <= fx; ++i) {
if (a[i][sy] == '.') return 0;
if (a[i][fy] == '.') return 0;
}
for (int j = sy; j <= fy; ++j) {
if (a[sx][j] == '.') return 0;
if (a[fx][j] == '.') return 0;
}
return 1;
}
inline void fill(int sx, int sy, int fx, int fy, char sym) {
for (int i = sx; i <= fx; ++i) {
a[i][sy] = sym;
a[i][fy] = sym;
}
for (int j = sy; j <= fy; ++j) {
a[sx][j] = sym;
a[fx][j] = sym;
}
}
vector<pair<int, int> > col;
inline void check(int sx, int sy, int fx, int fy) {
if (fx - sx < 2) return;
if (fy - sy < 2) return;
if (!rect(sx, sy, fx, fy)) return;
fill(sx, sy, fx, fy, '?');
bool alf = true;
int mnx = 1000000000, mxx = -1000000000, mny = 1000000000, mxy = -1000000000;
for (int i = 0; i < (int)(col).size(); ++i) {
if (a[col[i].first][col[i].second] == '#') {
alf = false;
mnx = min(mnx, col[i].first);
mxx = max(mnx, col[i].first);
mny = min(mny, col[i].second);
mxy = max(mny, col[i].second);
}
}
if (alf) {
cout << "YES\n";
cout << sx + 1 << " " << sy + 1 << " " << fx + 1 << " " << fy + 1 << endl;
cout << sx + 1 << " " << sy + 1 << " " << fx + 1 << " " << fy + 1 << endl;
exit(0);
}
vector<int> xx(0);
xx.push_back(sx);
xx.push_back(fx);
xx.push_back(mnx);
xx.push_back(mxx);
vector<int> yy(0);
yy.push_back(sy);
yy.push_back(fy);
yy.push_back(mny);
yy.push_back(mxy);
sort((xx).begin(), (xx).end());
xx.resize(unique((xx).begin(), (xx).end()) - xx.begin());
sort((yy).begin(), (yy).end());
yy.resize(unique((yy).begin(), (yy).end()) - yy.begin());
for (int ix = 0; ix < (int)(xx).size(); ++ix) {
for (int jx = ix + 1; jx < (int)(xx).size(); ++jx) {
if (xx[jx] - xx[ix] < 2) continue;
for (int iy = 0; iy < (int)(yy).size(); ++iy) {
for (int jy = iy + 1; jy < (int)(yy).size(); ++jy) {
if (yy[jy] - yy[iy] < 2) continue;
bool ok = true;
for (int i = 0; i < (int)(col).size(); ++i) {
if (a[col[i].first][col[i].second] == '#') {
if ((col[i].first == xx[ix] || col[i].first == xx[jx]) &&
col[i].second >= yy[iy] && col[i].second <= yy[jy])
continue;
if ((col[i].second == yy[iy] || col[i].second == yy[jy]) &&
col[i].first >= xx[ix] && col[i].first <= xx[jx])
continue;
ok = false;
break;
}
}
ok &= rect(xx[ix], yy[iy], xx[jx], yy[jy]);
if (ok) {
cout << "YES\n";
cout << sx + 1 << " " << sy + 1 << " " << fx + 1 << " " << fy + 1
<< endl;
cout << xx[ix] + 1 << " " << yy[iy] + 1 << " " << xx[jx] + 1 << " "
<< yy[jy] + 1 << endl;
exit(0);
}
}
}
}
}
fill(sx, sy, fx, fy, '#');
}
inline void check2(pair<int, int> sa, pair<int, int> fa, pair<int, int> sb,
pair<int, int> fb) {
if (!rect(sa.first, sa.second, fa.first, fa.second)) return;
if (!rect(sb.first, sb.second, fb.first, fb.second)) return;
fill(sa.first, sa.second, fa.first, fa.second, '?');
fill(sb.first, sb.second, fb.first, fb.second, '?');
bool ok = 1;
for (int i = 0; i < (int)(col).size(); ++i) {
if (a[col[i].first][col[i].second] == '#') {
ok = 0;
break;
}
}
if (ok) {
cout << "YES\n";
cout << sa.first + 1 << " " << sa.second + 1 << " " << fa.first + 1 << " "
<< fa.second + 1 << endl;
cout << sb.first + 1 << " " << sb.second + 1 << " " << fb.first + 1 << " "
<< fb.second + 1 << endl;
exit(0);
}
fill(sa.first, sa.second, fa.first, fa.second, '#');
fill(sb.first, sb.second, fb.first, fb.second, '#');
}
int main() {
gets(a[0]);
sscanf(a[0], "%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
gets(a[i]);
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') col.push_back(make_pair(i, j));
}
}
pair<int, int> top = make_pair(-1, -1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') {
top = make_pair(i, j);
i = j = 1000000000;
}
}
}
vector<int> xc(0), yc(0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m;) {
int oj = j;
while (j < m && a[i][j] == '#') ++j;
if (j - oj > 4) {
xc.push_back(i);
break;
}
++j;
}
}
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n;) {
int oi = i;
while (i < n && a[i][j] == '#') ++i;
if (i - oi > 4) {
yc.push_back(j);
break;
}
++i;
}
}
if ((int)(xc).size() < 5 && (int)(yc).size() < 5) {
vector<pair<pair<int, int>, pair<int, int> > > vp(0);
sort((xc).begin(), (xc).end());
sort((yc).begin(), (yc).end());
for (int ix = 0; ix < (int)(xc).size(); ++ix)
for (int jx = ix + 1; jx < (int)(xc).size(); ++jx)
if (xc[jx] - xc[ix] > 1)
for (int iy = 0; iy < (int)(yc).size(); ++iy)
for (int jy = iy + 1; jy < (int)(yc).size(); ++jy)
if (yc[jy] - yc[iy] > 1) {
vp.push_back(make_pair(make_pair(xc[ix], yc[iy]),
make_pair(xc[jx], yc[jy])));
}
for (int i = 0; i < (int)(vp).size(); ++i)
for (int j = 0; j < (int)(vp).size(); ++j) {
check2(vp[i].first, vp[i].second, vp[j].first, vp[j].second);
}
}
for (int i = n - 1; i > 0; --i) {
for (int j = m - 1; j > 0; --j) {
if (a[i][j] == '#' && a[i - 1][j] == '#' && a[i][j - 1] == '#') {
check(top.first, top.second, i, j);
}
}
}
cout << "NO\n";
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int main() {
string s, t;
int n;
cin >> n;
cin >> s >> t;
for (int i = 0; i < n; ++i) a[i] = s[i] - 'a' + t[i] - 'a';
for (int i = n - 1; i; --i) {
if (a[i] >= 26) {
a[i] -= 26;
++a[i - 1];
}
}
for (int i = 0; i < n; ++i) {
if (a[i] % 2) a[i + 1] += 26;
a[i] /= 2;
cout << (char)(a[i] + 'a');
}
cout << '\n';
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void zaroorat() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
zaroorat();
long long n;
cin >> n;
std::map<char, int> map;
string inp;
cin >> inp;
for (size_t i = 0; i < inp.size(); i++) {
map[inp[i]] += 1;
}
if (map['A'] > map['D']) {
cout << "Anton" << endl;
} else if (map['A'] < map['D']) {
cout << "Danik" << endl;
} else {
cout << "Friendship" << endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
int main() {
char c[11][11];
int p, i, j, k, v;
p = 0;
for (i = 1; i <= 8; i++) {
for (j = 1; j <= 8; j++) {
scanf("%c", &c[i][j]);
}
getchar();
}
for (k = 1; k <= 8; k++) {
for (v = 1; v <= 7; v++) {
if (c[k][v] == c[k][v + 1]) {
p = 1;
}
}
}
if (p == 0) {
printf("YES\n");
}
if (p == 1) {
printf("NO\n");
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int d(int x) {
int z = 0, c = x;
while (c) {
z |= (1 << (c % 10));
c /= 10;
}
return __builtin_popcount(z);
}
void solve() {
int n, k;
cin >> n >> k;
while (d(n) > k) {
int r = 1, c = n;
while (d(c) > k) {
c /= 10;
r *= 10;
}
r /= 10;
n = ((n / r) + 1) * r;
}
cout << n << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void checkMin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
inline void checkMax(T &a, T b) {
if (a < b) a = b;
}
const int MAX_N = 1024;
int n, m, q;
struct Bit2D {
int n = 1000, bit[MAX_N][MAX_N];
void add(int x, int y, int d) {
for (int yy = y; x <= n; x += x & -x) {
for (y = yy; y <= n; y += y & -y) {
bit[x][y] += d;
}
}
}
int prefix(int x, int y) {
int s = 0;
for (int yy = y; x > 0; x -= x & -x) {
for (y = yy; y > 0; y -= y & -y) {
s += bit[x][y];
}
}
return s;
}
int query(int x1, int x2, int y1, int y2) {
return prefix(x2, y2) - prefix(x1 - 1, y2) - prefix(x2, y1 - 1) +
prefix(x1 - 1, y1 - 1);
}
bool check(int x1, int x2, int y1, int y2) {
return (x2 - x1 + 1) * (y2 - y1 + 1) == query(x1, x2, y1, y2);
}
} t;
int calc_up(int x, int y) {
int ans = 0, l = y, r = y, flag = false;
for (int o = n; o >= x; --o) {
if (flag || t.check(x, o, l, r)) {
flag = true;
while (1 < l && t.check(x, o, l - 1, r)) --l;
while (r < m && t.check(x, o, l, r + 1)) ++r;
checkMax(ans, (o - x + 1) * (r - l + 1));
}
}
return ans;
}
int calc_dn(int x, int y) {
int ans = 0, l = y, r = y, flag = false;
for (int o = 1; o <= x; ++o) {
if (flag || t.check(o, x, l, r)) {
flag = true;
while (1 < l && t.check(o, x, l - 1, r)) --l;
while (r < m && t.check(o, x, l, r + 1)) ++r;
checkMax(ans, (x - o + 1) * (r - l + 1));
}
}
return ans;
}
int calc_lt(int x, int y) {
int ans = 0, l = x, r = x, flag = false;
for (int o = m; o >= y; --o) {
if (flag || t.check(l, r, y, o)) {
flag = true;
while (1 < l && t.check(l - 1, r, y, o)) --l;
while (r < n && t.check(l, r + 1, y, o)) ++r;
checkMax(ans, (o - y + 1) * (r - l + 1));
}
}
return ans;
}
int calc_rt(int x, int y) {
int ans = 0, l = x, r = x, flag = false;
for (int o = 1; o <= y; ++o) {
if (flag || t.check(l, r, o, y)) {
flag = true;
while (1 < l && t.check(l - 1, r, o, y)) --l;
while (r < n && t.check(l, r + 1, o, y)) ++r;
checkMax(ans, (y - o + 1) * (r - l + 1));
}
}
return ans;
}
int work(int x, int y) {
int ans = 0;
checkMax(ans, calc_up(x, y));
checkMax(ans, calc_dn(x, y));
checkMax(ans, calc_lt(x, y));
checkMax(ans, calc_rt(x, y));
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int a;
scanf("%d", &a);
if (a) {
t.add(i, j, 1);
}
}
}
int op, x, y;
for (int i = 0; i < int(q); ++i) {
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
t.add(x, y, t.query(x, x, y, y) == 0 ? 1 : -1);
} else {
printf("%d\n", t.check(x, x, y, y) ? work(x, y) : 0);
}
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
locale loc;
map<string, int> mp;
string x, y, z;
int N;
cin >> N;
mp["polycarp"]++;
int maxAns = 0;
while (N--) {
cin >> x >> y >> z;
transform(x.begin(), x.end(), x.begin(), ::tolower);
transform(z.begin(), z.end(), z.begin(), ::tolower);
mp[x] = mp[z] + 1;
if (mp[x] > maxAns) maxAns = mp[x];
}
cout << maxAns << endl;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int N, K, in[30010];
vector<vector<int> > cdp(30010, vector<int>(2));
vector<vector<int> > ndp(30010, vector<int>(2));
int f[2][2];
int main() {
scanf("%d%d", &N, &K);
--K;
for (int i = 0; i < N; ++i) scanf("%d", &in[i]);
int mins = 0, maxs = 0;
for (int i = 0; i < N; ++i)
mins = min(mins, 0) + in[i], maxs = max(maxs, 0) + in[i], cdp[i][0] = maxs,
cdp[i][1] = -mins;
for (int p = 1; p < K; ++p) {
f[0][0] = f[0][1] = -1000000000;
f[1][0] = f[1][1] = -1000000000;
ndp[0][0] = ndp[0][1] = -1000000000;
for (int i = 1; i < N; ++i) {
f[0][1] -= 2 * in[i];
f[1][0] += 2 * in[i];
(f[0][0]) = max((f[0][0]), (cdp[i - 1][0]));
(f[0][1]) = max((f[0][1]), (cdp[i - 1][0] - 2 * in[i]));
(f[1][0]) = max((f[1][0]), (cdp[i - 1][1] + 2 * in[i]));
(f[1][1]) = max((f[1][1]), (cdp[i - 1][1]));
ndp[i][0] = max(f[0][0], f[1][0]);
ndp[i][1] = max(f[0][1], f[1][1]);
}
cdp.swap(ndp);
for (int i = 1; i < N; ++i)
(cdp[i][0]) = max((cdp[i][0]), (cdp[i - 1][0])),
(cdp[i][1]) = max((cdp[i][1]), (cdp[i - 1][1]));
}
int ans = -1000000000;
mins = maxs = 0;
for (int i = N - 1; i > 0; --i)
mins = min(mins, 0) + in[i], maxs = max(maxs, 0) + in[i],
(ans) = max((ans), (cdp[i - 1][0] - mins)),
(ans) = max((ans), (cdp[i - 1][1] + maxs));
printf("%d\n", ans);
return 0;
}
| 19
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const long long INF = ((1 << 31) - 1);
const long long LLINF = (((1LL << 63) - 1LL));
const double EPS = 1e-9;
const double PI = 3.14159265358979323846;
pair<long long, long long> operator+(const pair<long long, long long>& lhs,
const pair<long long, long long>& rhs) {
return pair<long long, long long>(lhs.first + rhs.first,
lhs.second + rhs.second);
}
pair<long long, long long> play(char a, char b) {
if (a == b) {
return pair<long long, long long>(0, 0);
}
if (a == 'R') {
if (b == 'S') {
return pair<long long, long long>(0, 1);
} else {
return pair<long long, long long>(1, 0);
}
}
if (a == 'S') {
if (b == 'P') {
return pair<long long, long long>(0, 1);
} else {
return pair<long long, long long>(1, 0);
}
}
if (a == 'P') {
if (b == 'R') {
return pair<long long, long long>(0, 1);
} else {
return pair<long long, long long>(1, 0);
}
}
assert(false);
}
pair<long long, long long> solve(const string& a, const string& b, int n) {
int M = a.size() * b.size();
string aa;
for (int i = 0; i < M / a.size(); ++i) {
aa += a;
}
string bb;
for (int i = 0; i < M / b.size(); ++i) {
bb += b;
}
long long times = n / M;
long long pred = n % M;
pair<long long, long long> res(0, 0);
for (int i = 0; i < pred; ++i) {
pair<long long, long long> add = play(aa[i], bb[i]);
res = res + add;
}
pair<long long, long long> perPer(0, 0);
for (int i = 0; i < M; ++i) {
pair<long long, long long> add = play(aa[i], bb[i]);
perPer = perPer + add;
}
res.first += perPer.first * times;
res.second += perPer.second * times;
return res;
}
int main() {
int n;
cin >> n;
string a, b;
cin >> a >> b;
pair<long long, long long> res = solve(a, b, n);
cout << res.first << " " << res.second << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int VT[5], PT[5];
int solves[5];
int nsolves[5];
int N;
int calcscore(int A[], int totp) {
int total = 0;
for (int i = 0; i < 5; i++) {
if (A[i] == -1) continue;
int pvalue = 500;
for (int j = 1; j < 6; j++, pvalue += 500)
if ((1 << j) * nsolves[i] > totp) break;
total += (250 - A[i]) * (pvalue / 250);
}
return total;
}
bool check(int x) {
for (int i = 0; i < 5; i++) nsolves[i] = solves[i];
for (int i = 0; i < 5; i++)
if (VT[i] != -1 && PT[i] != -1 && VT[i] > PT[i]) {
nsolves[i] += x;
}
int totp = x + N;
if (calcscore(VT, totp) > calcscore(PT, totp)) return true;
return false;
}
int main() {
cin >> N;
for (int i = 0; i < 5; i++) {
cin >> VT[i];
if (VT[i] != -1) solves[i] += 1;
}
for (int i = 0; i < 5; i++) {
cin >> PT[i];
if (PT[i] != -1) solves[i] += 1;
}
for (int i = 2; i < N; i++)
for (int j = 0; j < 5; j++) {
int x;
cin >> x;
if (x != -1) solves[j] += 1;
}
vector<int> limits;
limits.push_back(0);
limits.push_back(1000000007);
for (int i = 0; i < 5; i++)
if (VT[i] == -1 && PT[i] != -1) {
for (int j = 1; j <= 5; j++)
if ((1 << j) * solves[i] - N > 0)
limits.push_back((1 << j) * solves[i] - N);
}
sort(limits.begin(), limits.end());
for (int i = 0; i + 1 < limits.size(); i++) {
if (limits[i] == limits[i + 1]) continue;
int lo = limits[i], hi = limits[i + 1] - 1;
while (lo < hi - 1) {
int mid = (lo + hi) >> 1;
if (check(mid))
hi = mid;
else
lo = mid + 1;
}
if (check(lo)) hi = lo;
if (check(hi)) {
cout << hi << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << 2 * n - 1 << " 2 \n1 2";
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
long long int Cube_Root(long long int x) {
long long int l = 1, r = 1000005;
while (l < r) {
long long int mid = (l + r) / 2;
if (mid * mid * mid >= x) {
r = mid;
} else {
l = mid + 1;
}
}
if (l * l * l > x) {
return l - 1;
} else {
return l;
}
}
int main() {
int n;
scanf("%d", &n);
while (n--) {
long long int a, b, temp;
scanf("%lld%lld", &a, &b);
temp = Cube_Root(a * b);
if ((temp * temp * temp == a * b) && (a % temp == 0) && (b % temp == 0)) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> graph(200009);
long long visi[200009];
long long n, m, a, b, c;
void bfs(long long s, vector<long long>& dist) {
for (int i = 1; i <= n; i++) visi[i] = 0;
queue<long long> q;
q.push(s);
visi[s] = 1;
while (!q.empty()) {
long long x = q.front();
q.pop();
for (long long i = 0; i < graph[x].size(); i++) {
if (visi[graph[x][i]] == 0) {
visi[graph[x][i]] = 1;
dist[graph[x][i]] = dist[x] + 1;
q.push(graph[x][i]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
cin >> n >> m >> a >> b >> c;
for (long long i = 0; i <= n; i++) graph[i].clear();
vector<long long> weights;
for (int i = 0; i < m; i++) {
long long x;
cin >> x;
weights.push_back(x);
}
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
graph[y].push_back(x);
graph[x].push_back(y);
}
sort(weights.begin(), weights.end());
vector<long long> prefix;
prefix.push_back(weights[0]);
for (int i = 1; i < weights.size(); i++) {
prefix.push_back(prefix[i - 1] + weights[i]);
}
vector<long long> dist_a(n + 2);
vector<long long> dist_b(n + 2);
vector<long long> dist_c(n + 2);
bfs(a, dist_a);
bfs(b, dist_b);
bfs(c, dist_c);
long long ans = 1e17;
for (int i = 1; i <= n; i++) {
if (dist_b[i] + dist_a[i] + dist_c[i] <= m) {
if (dist_b[i] > 0 && dist_b[i] + dist_a[i] + dist_c[i] > 0)
ans = min(ans, prefix[dist_b[i] - 1] +
prefix[dist_b[i] + dist_a[i] + dist_c[i] - 1]);
else if (dist_b[i] + dist_a[i] + dist_c[i] > 0)
ans = min(ans, prefix[dist_b[i] + dist_a[i] + dist_c[i] - 1]);
else
ans = 0;
}
}
if (ans >= 0 && ans < 1e17)
cout << ans << "\n";
else
cout << "0\n";
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b;
vector<int> c;
long long func(int l, int h) {
long long ans;
long long lb = lower_bound(c.begin(), c.end(), l) - c.begin();
long long ub = upper_bound(c.begin(), c.end(), h) - c.begin();
long long z = ub - lb;
long long mid = (l + h) / 2;
if (z == 0) {
ans = a;
} else {
ans = b * z * (h - l + 1);
}
if (z == 0 || l == h) {
return ans;
}
return (min(func(l, mid) + func(mid + 1, h), ans));
}
int main() {
cin >> n >> k >> a >> b;
for (int i = 0; i < k; i++) {
int f;
cin >> f;
c.push_back(f);
}
sort(c.begin(), c.end());
n = 1 << n;
cout << func(1, n);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, inf = 1061109567;
const long long infll = 4557430888798830399;
const int N = 1005;
int n, k1, k2, p[N], revp[N];
vector<int> g[N];
bool set1[N], set2[N];
int ask(char c, int x) {
x++;
cout << c << " " << x << "\n";
fflush(stdout);
int ans;
cin >> ans;
if (ans == -1) exit(0);
ans--;
return ans;
}
void answer(int x) {
if (x != -1) x++;
cout << "C " << x << "\n";
fflush(stdout);
}
const int LOG = 13, ROOT = 0;
int dep[N], par[N][LOG];
void dfs(int u, int p) {
par[u][0] = p;
for (auto v : g[u])
if (v != p) {
dep[v] = dep[u] + 1;
dfs(v, u);
}
}
void sparse() {
for (int j = 1; j < LOG; j++)
for (int i = 0; i < n; i++)
if (par[i][j - 1] != -1) {
par[i][j] = par[par[i][j - 1]][j - 1];
}
}
int getLCA(int u, int v) {
if (u == -1) return v;
if (v == -1) return u;
if (dep[u] < dep[v]) swap(u, v);
int diff = dep[u] - dep[v];
for (int i = 0; i < LOG; i++)
if (diff & (1 << i)) u = par[u][i];
if (u == v) return u;
for (int i = LOG - 1; i >= 0; i--)
if (par[u][i] != par[v][i]) {
u = par[u][i], v = par[v][i];
}
return par[u][0];
}
int almostLCA(int u, int v) {
assert(dep[u] > dep[v]);
int diff = dep[u] - dep[v] - 1;
for (int i = 0; i < LOG; i++)
if (diff & (1 << i)) u = par[u][i];
return u;
}
void proc() {
cin >> n;
for (int i = 0; i < n; i++) {
g[i].clear();
set1[i] = set2[i] = 0;
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v), g[v].push_back(u);
}
dep[ROOT] = 0;
memset(par, -1, sizeof par);
dfs(ROOT, -1);
sparse();
int k1, k2;
cin >> k1;
int lcaX = -1;
while (k1--) {
int x;
cin >> x;
x--;
set1[x] = 1;
lcaX = getLCA(lcaX, x);
}
int foist = -1;
cin >> k2;
while (k2--) {
int x;
cin >> x;
x--;
foist = x;
set2[x] = 1;
}
int v = ask('B', foist);
int cur = ROOT;
while (!set1[cur]) {
if (cur == v) {
int other = ask('A', lcaX);
if (set2[other])
answer(lcaX);
else
answer(-1);
return;
}
int almostV = almostLCA(v, cur), almostX = almostLCA(lcaX, cur);
if (almostV != almostX) {
int other = ask('A', lcaX);
if (set2[other])
answer(lcaX);
else
answer(-1);
return;
} else {
cur = almostV;
}
}
int otherCur = ask('A', cur);
if (set2[otherCur]) {
answer(cur);
return;
}
while (1) {
if (set1[v]) {
int otherV = ask('A', v);
if (set2[otherV])
answer(v);
else
answer(-1);
return;
} else
v = par[v][0];
}
}
signed main() {
int t;
cin >> t;
while (t--) proc();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, nxt, w;
} edge[200010 * 2];
int col[200010], fir[200010], sec[200010], head[200010], tot, w[200010];
void Add(int u, int v, int w) {
edge[tot] = (Edge){v, head[u], w};
head[u] = tot++;
edge[tot] = (Edge){u, head[v], w};
head[v] = tot++;
}
bool dfs(int u) {
for (int i = head[u]; ~i; i = edge[i].nxt) {
int v = edge[i].v, w = edge[i].w;
if (col[v] == -1) {
col[v] = col[u] ^ w;
if (!dfs(v)) return false;
} else if (col[u] ^ col[v] ^ w)
return false;
}
return true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &w[i]), w[i] ^= 1;
for (int i = 1; i <= m; i++) {
int k;
scanf("%d", &k);
while (k--) {
int a;
scanf("%d", &a);
if (fir[a] == 0)
fir[a] = i;
else
sec[a] = i;
}
}
memset(head, -1, sizeof(head));
tot = 0;
for (int i = 1; i <= n; i++) Add(fir[i], sec[i], w[i]);
memset(col, -1, sizeof(col));
bool flag = 1;
for (int i = 1; i <= m; i++) {
if (col[i] == -1) {
col[i] = 0;
if (!dfs(i)) {
flag = 0;
break;
}
}
}
if (!flag)
puts("NO");
else
puts("YES");
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> g[N];
int n, start[N], finish[N];
int dep[N];
void load_tree() {
scanf("%d", &n);
for (long long i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
}
int Time = 0;
int up[20][N];
void dfs(int u, int p, int d) {
dep[u] = d;
up[0][u] = p;
start[u] = ++Time;
for (long long go = 1; go <= 18; go++) up[go][u] = up[go - 1][up[go - 1][u]];
for (long long i = 0; i < g[u].size(); i++) {
if (g[u][i] != p) dfs(g[u][i], u, d + 1);
}
finish[u] = ++Time;
}
int Lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int d = dep[u] - dep[v];
for (int go = 18; go >= 0; go--) {
if (d & (1 << (go))) u = up[go][u];
}
if (u == v) return u;
for (int go = 18; go >= 0; go--) {
if (up[go][u] != up[go][v]) {
u = up[go][u];
v = up[go][v];
}
}
return up[0][u];
}
bool comp_discover(int u, int v) { return start[u] < start[v]; }
vector<int> btr[N];
bool inside(int v, int u) {
return start[u] < start[v] && finish[v] < finish[u];
}
int f[N];
bool black[N];
void minimize(int &u, int v) { u = min(u, v); }
int ans = 0;
int find_ans(int u) {
for (__typeof(btr[u]).begin() it = (btr[u]).begin(); it != (btr[u]).end();
it++)
f[*it] = find_ans(*it);
if (black[u]) {
for (__typeof(btr[u]).begin() it = (btr[u]).begin(); it != (btr[u]).end();
it++) {
ans += f[*it];
if (black[*it]) ans += 1;
}
return 0;
} else {
int sum_still = 0;
for (__typeof(btr[u]).begin() it = (btr[u]).begin(); it != (btr[u]).end();
it++)
sum_still += f[*it];
for (__typeof(btr[u]).begin() it = (btr[u]).begin(); it != (btr[u]).end();
it++)
if (black[*it]) sum_still++;
if (sum_still >= 2) {
ans += 1;
return 0;
}
if (sum_still == 0) return 0;
if (sum_still == 1) return 1;
}
}
void process(int lan) {
int nuts;
scanf("%d", &nuts);
vector<int> tap;
for (long long i = 1; i <= nuts; i++) {
int x;
scanf("%d", &x);
black[x] = true;
tap.push_back(x);
}
sort(tap.begin(), tap.end(), comp_discover);
unique(tap.begin(), tap.end());
int s = tap.size();
for (__typeof(tap).begin() it = (tap).begin(); it != (tap).end(); it++) {
int v = *it;
if (v == 1) continue;
if (black[up[0][v]] == true) {
for (__typeof(tap).begin() it = (tap).begin(); it != (tap).end(); it++)
black[*it] = false;
printf("-1\n");
return;
}
}
for (long long i = 0; i < s - 1; i++) {
tap.push_back(Lca(tap[i], tap[i + 1]));
}
sort(tap.begin(), tap.end(), comp_discover);
tap.resize(unique(tap.begin(), tap.end()) - tap.begin());
for (__typeof(tap).begin() it = (tap).begin(); it != (tap).end(); it++) {
f[*it] = 0;
btr[*it].clear();
}
stack<int> tem;
for (__typeof(tap).begin() it = (tap).begin(); it != (tap).end(); it++) {
while (!tem.empty()) {
if (inside(*it, tem.top())) {
break;
}
tem.pop();
}
if (!tem.empty()) btr[tem.top()].push_back(*it);
tem.push(*it);
}
ans = 0;
find_ans(tap[0]);
for (__typeof(tap).begin() it = (tap).begin(); it != (tap).end(); it++) {
f[*it] = 0;
black[*it] = false;
btr[*it].clear();
}
printf("%d\n", ans);
}
int main() {
load_tree();
dfs(1, 1, 1);
int q;
scanf("%d", &q);
for (long long i = 1; i <= q; i++) {
process(i);
}
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100 * 1000 + 10;
const long long D = 1000ll * 1000 * 1000 + 7;
pair<int, long long> par[Maxn];
pair<int, long long> find(int v) {
if (v == par[v].first) return par[v];
pair<int, long long> ret = find(par[v].first);
par[v] = pair<int, long long>(ret.first,
(((ret.second + par[v].second) % D) + D) % D);
return par[v];
}
long long n, ret;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
long long k, v, x;
cin >> k;
par[i].first = i;
for (int j = 0; j < k; j++) {
cin >> v >> x;
find(v);
ret = (((ret + x + par[v].second) % D) + D) % D;
par[par[v].first] = pair<int, long long>(i, par[v].second + x);
}
}
cout << ret << endl;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void print_2darray(const char* second, T arr, int n, int m) {
cout << "> " << second << endl;
cout << "[" << endl;
for (int i = 0; i < n; i++) {
cout << "{";
for (int j = 0; j < m; j++) {
cout << arr[i][j] << (j == m - 1 ? "" : ",");
}
cout << "}" << endl;
}
cout << "]" << endl;
}
template <class T>
void print_1darray(const char* second, T arr, int n) {
cout << "> " << second << endl;
cout << "[" << endl;
for (int i = 0; i < n; i++) {
cout << arr[i] << (i == n - 1 ? "" : ",");
}
cout << endl << "]" << endl;
}
const long long int N = 200000;
long long int n;
long long int n1[N];
long long int n2[N];
vector<long long int> edges[N + 1];
vector<long long int> w[N + 1];
vector<long long int> second[N + 1];
long long int max_decrease[N + 1];
long long int w_sum[N + 1];
long long int total[N + 1];
long long int new_w[N + 1];
long long int new_s[N + 1];
void dfs(long long int cur, long long int rem, long long int weight,
long long int strength) {
if (cur == 1) {
for (int i = 0; i < edges[cur].size(); i++) {
dfs(edges[cur][i], 0, w[cur][i], second[cur][i]);
}
return;
}
long long int temp = 0, tot = 0;
for (int i = 0; i < edges[cur].size(); i++) {
temp += max_decrease[edges[cur][i]];
tot += total[edges[cur][i]];
}
if (tot > strength) {
rem += tot - strength;
}
if (temp < rem) {
new_w[cur] = weight - rem + temp;
new_s[cur] = strength - rem + temp;
rem = temp;
} else {
new_w[cur] = weight;
new_s[cur] = strength;
}
for (int i = 0; i < edges[cur].size(); i++) {
dfs(edges[cur][i], min(rem, max_decrease[edges[cur][i]]), w[cur][i],
second[cur][i]);
rem -= min(rem, max_decrease[edges[cur][i]]);
}
}
bool dfs_max_decrease(long long int cur, long long int weight,
long long int strength) {
for (int i = 0; i < edges[cur].size(); i++) {
if (!dfs_max_decrease(edges[cur][i], w[cur][i], second[cur][i])) {
return false;
}
w_sum[cur] += w_sum[edges[cur][i]];
max_decrease[cur] += max_decrease[edges[cur][i]];
total[cur] += total[edges[cur][i]];
}
if (cur == 1) {
return true;
}
if (strength < w_sum[cur]) {
return false;
}
max_decrease[cur] += min(strength - w_sum[cur], weight - 1);
w_sum[cur] += weight - min(strength - w_sum[cur], weight - 1);
if (total[cur] > strength) {
max_decrease[cur] -= total[cur] - strength;
total[cur] = strength;
}
total[cur] += weight;
return true;
}
int main() {
cin >> n;
long long int from, to, weight, str;
for (int i = 0; i < n - 1; i++) {
cin >> from >> to >> weight >> str;
n1[i] = from;
n2[i] = to;
edges[from].push_back(to);
w[from].push_back(weight);
second[from].push_back(str);
}
if (!dfs_max_decrease(1, 0, 0)) {
cout << -1;
return 0;
}
dfs(1, 0, 0, 0);
cout << n << endl;
for (int i = 0; i < n - 1; i++) {
cout << n1[i] << " " << n2[i] << " " << new_w[n2[i]] << " " << new_s[n2[i]]
<< endl;
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int a[256][256];
int main() {
int n;
scanf("%d", &n);
char s[15];
for (int i = 1; i <= n; i++) {
scanf("%s", s);
int sl = strlen(s);
char f = s[0], l = s[sl - 1];
for (int j = 'a'; j <= 'z'; j++) {
int neu = a[j][f] + sl;
if (a[j][f]) a[j][l] = max(a[j][l], neu);
}
a[f][l] = max(a[f][l], sl);
}
int ans = 0;
for (int i = 'a'; i <= 'z'; i++) ans = max(ans, a[i][i]);
printf("%d\n", ans);
return 0;
}
| 7
|
#include <bits/stdc++.h>
const int N = 1e5 + 5;
long long Mod;
template <class T>
inline void read(T &first) {
first = 0;
T f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
first = first * 10 + c - '0';
c = getchar();
}
first *= f;
}
inline void write(long long first) {
if (first >= 10) write(first / 10);
putchar('0' + first % 10);
}
inline long long Pow(long long a, int b) {
long long ans = 1;
for (; b > 0; b >>= 1, a = a * a)
if (b & 1) ans = ans * a;
return ans;
}
template <class T>
inline T exgcd(T a, T b, T &first, T &second) {
if (!b) {
first = 1, second = 0;
return a;
}
T t, ret;
ret = exgcd(b, a % b, first, second);
t = first, first = second, second = t - a / b * second;
return ret;
}
inline long long qpow(long long a, long long b) {
long long ans = 1;
for (; b > 0; b >>= 1, a = a * a % Mod)
if (b & 1) ans = ans * a % Mod;
return ans;
}
inline long long Inv(long long first) {
long long inv, y0;
exgcd(first, Mod, inv, y0);
return (inv % Mod + Mod) % Mod;
}
using namespace std;
int p[N], notp[N];
void init() {
notp[1] = 1;
for (int i = 2; i <= 100000; ++i) {
if (!notp[i]) p[++p[0]] = i;
for (int j = 1; j <= p[0] && p[j] * i <= 100000; ++j) {
notp[p[j] * i] = 1;
if (i % p[j] == 0) break;
}
}
}
int cc = 0, n, a[N], q;
long long pm[9], pmp[9][1700000];
struct Node {
long long Tag1[9], Tag2, sum;
Node() { Tag2 = 1; }
void ins(long long first) {
for (int i = 0; i < cc; ++i) {
Tag1[i] = 0;
if (first % pm[i] == 0) {
while (first % pm[i] == 0) first /= pm[i], ++Tag1[i];
}
}
Tag2 = first % Mod;
}
} T[N << 2];
void build(int p, int l, int r) {
if (l == r) {
T[p].ins(a[l]);
T[p].sum = a[l] % Mod;
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r);
T[p].sum = (T[p << 1].sum + T[p << 1 | 1].sum) % Mod;
}
void PushDown(int p) {
if (T[p].Tag2 != 1) {
T[p << 1].Tag2 = T[p << 1].Tag2 * T[p].Tag2 % Mod;
T[p << 1].sum = T[p << 1].sum * T[p].Tag2 % Mod;
T[p << 1 | 1].Tag2 = T[p << 1 | 1].Tag2 * T[p].Tag2 % Mod;
T[p << 1 | 1].sum = T[p << 1 | 1].sum * T[p].Tag2 % Mod;
T[p].Tag2 = 1;
}
for (int i = 0; i < cc; ++i)
if (T[p].Tag1[i] != 0) {
T[p << 1].Tag1[i] += T[p].Tag1[i];
T[p << 1].sum = T[p << 1].sum * pmp[i][T[p].Tag1[i]] % Mod;
T[p << 1 | 1].Tag1[i] += T[p].Tag1[i];
T[p << 1 | 1].sum = T[p << 1 | 1].sum * pmp[i][T[p].Tag1[i]] % Mod;
T[p].Tag1[i] = 0;
}
}
void Mul(int p, int l, int r, int L, int R, const Node &A) {
if (l == L && r == R) {
for (int i = 0; i < cc; ++i)
T[p].Tag1[i] = T[p].Tag1[i] + A.Tag1[i],
T[p].sum = T[p].sum * pmp[i][A.Tag1[i]] % Mod;
T[p].Tag2 = T[p].Tag2 * A.Tag2 % Mod;
T[p].sum = T[p].sum * A.Tag2 % Mod;
return;
}
PushDown(p);
int mid = (l + r) >> 1;
if (R <= mid)
Mul(p << 1, l, mid, L, R, A);
else if (L > mid)
Mul(p << 1 | 1, mid + 1, r, L, R, A);
else
Mul(p << 1, l, mid, L, mid, A), Mul(p << 1 | 1, mid + 1, r, mid + 1, R, A);
T[p].sum = (T[p << 1].sum + T[p << 1 | 1].sum) % Mod;
}
void Div(int p, int l, int r, const int &pos, const Node &A) {
if (l == r) {
T[p].sum = 1;
for (int i = 0; i < cc; ++i)
T[p].Tag1[i] -= A.Tag1[i],
T[p].sum = T[p].sum * pmp[i][T[p].Tag1[i]] % Mod;
T[p].Tag2 = T[p].Tag2 * Inv(A.Tag2) % Mod;
T[p].sum = T[p].sum * T[p].Tag2 % Mod;
return;
}
PushDown(p);
int mid = (l + r) >> 1;
if (pos <= mid)
Div(p << 1, l, mid, pos, A);
else
Div(p << 1 | 1, mid + 1, r, pos, A);
T[p].sum = (T[p << 1].sum + T[p << 1 | 1].sum) % Mod;
}
long long Ask(int p, int l, int r, int L, int R) {
if (l == L && r == R) return T[p].sum;
PushDown(p);
int mid = (l + r) >> 1;
if (R <= mid)
return Ask(p << 1, l, mid, L, R);
else if (L > mid)
return Ask(p << 1 | 1, mid + 1, r, L, R);
return (Ask(p << 1, l, mid, L, mid) +
Ask(p << 1 | 1, mid + 1, r, mid + 1, R)) %
Mod;
T[p].sum = (T[p << 1].sum + T[p << 1 | 1].sum) % Mod;
}
int main() {
init();
read(n), read(Mod);
for (int i = 1; i <= n; ++i) read(a[i]);
long long tmp = Mod;
for (int i = 1; p[i] * p[i] <= tmp; ++i)
if (tmp % p[i] == 0) {
pm[cc++] = p[i];
while (tmp % p[i] == 0) tmp /= p[i];
}
if (tmp != 1) pm[cc++] = tmp;
for (int i = 0; i < cc; ++i) {
pmp[i][0] = 1;
for (int j = 1; j <= 1700000 - 1; ++j)
pmp[i][j] = pmp[i][j - 1] * pm[i] % Mod;
}
build(1, 1, n);
int q, opt, l, r, first;
Node A;
read(q);
while (q--) {
read(opt);
if (opt == 1) {
read(l), read(r), read(first), A.ins(first);
Mul(1, 1, n, l, r, A);
} else if (opt == 2) {
read(l), read(first), A.ins(first);
Div(1, 1, n, l, A);
} else {
read(l), read(r);
write(Ask(1, 1, n, l, r)), putchar('\n');
}
}
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1002;
const long long oo = (int)1e9 + 7;
int vis[maxn][maxn][4];
char mp[maxn][maxn];
char door[maxn][maxn][4];
deque<pair<int, int> > qu;
deque<int> ro;
deque<int> tq;
int n, m;
pair<int, int> st, ed;
map<char, set<int> > indr;
int mx[4] = {-1, 0, 1, 0};
int my[4] = {0, 1, 0, -1};
bool ck(pair<int, int> now, int r, int d) {
int dr = (d - r + 4) % 4;
if (indr[mp[now.first][now.second]].count(dr)) return true;
return false;
}
bool check(pair<int, int> now, pair<int, int> to, int r, int d) {
if (now.first < 0 || now.second < 0 || now.first >= n || now.second >= m)
return false;
if (to.first < 0 || to.second < 0 || to.first >= n || to.second >= m)
return false;
if (vis[to.first][to.second][r] == 1) return false;
if (mp[to.first][to.second] == '*') return false;
if (ck(now, r, d) && ck(to, r, (d + 2) % 4)) return true;
return false;
}
void go(pair<int, int> now, int r, int t) {
if (vis[now.first][now.second][(r + 1) % 4] == 0) {
qu.push_back(now);
ro.push_back((r + 1) % 4);
tq.push_back(t + 1);
vis[now.first][now.second][(r + 1) % 4] = 1;
}
pair<int, int> tmp;
for (int i = 0; i < 4; i++) {
tmp.first = now.first + mx[i];
tmp.second = now.second + my[i];
if (check(now, tmp, r, i)) {
qu.push_back(tmp);
ro.push_back(r);
tq.push_back(t + 1);
vis[tmp.first][tmp.second][r] = 1;
}
}
}
int main() {
indr['+'].insert(0);
indr['+'].insert(1);
indr['+'].insert(2);
indr['+'].insert(3);
indr['-'].insert(1);
indr['-'].insert(3);
indr['|'].insert(0);
indr['|'].insert(2);
indr['^'].insert(0);
indr['>'].insert(1);
indr['<'].insert(3);
indr['v'].insert(2);
indr['L'].insert(0);
indr['L'].insert(1);
indr['L'].insert(2);
indr['R'].insert(0);
indr['R'].insert(2);
indr['R'].insert(3);
indr['U'].insert(1);
indr['U'].insert(2);
indr['U'].insert(3);
indr['D'].insert(1);
indr['D'].insert(3);
indr['D'].insert(0);
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", mp[i]);
scanf("%d%d", &st.first, &st.second);
scanf("%d%d", &ed.first, &ed.second);
st.first--;
st.second--;
ed.first--;
ed.second--;
vis[st.first][st.second][0] = 1;
qu.push_back(st);
ro.push_back(0);
tq.push_back(0);
pair<int, int> now;
int nro, t;
while (!qu.empty()) {
now = qu.front();
qu.pop_front();
nro = ro.front();
ro.pop_front();
t = tq.front();
tq.pop_front();
vis[now.first][now.second][nro] = 1;
if (now == ed) {
printf("%d\n", t);
return 0;
}
go(now, nro, t);
}
printf("-1\n");
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int T, n, k;
mt19937 mt(time(0) + (size_t) new int);
bool vis[N];
bool check_1() {
memset(vis, 0, n + 1);
string st;
for (int i = 1; i <= 20 && i < n; ++i) {
int p = mt() % (n - 1) + 2;
while (vis[p]) p = mt() % (n - 1) + 2;
vis[p] = 1;
cout << "? 1 1\n1\n" << p << endl;
cin >> st;
if (st == "SECOND") return 0;
}
return 1;
}
bool work(int l, int r) {
int m = r - l + 1;
cout << "? " << m << ' ' << m << '\n';
for (int i = 1; i <= m; ++i) cout << i << ' ';
cout << '\n';
for (int i = l; i <= r; ++i) cout << i << ' ';
cout << endl;
string st;
cin >> st;
if (st == "EQUAL") return 0;
if (st == "FIRST") {
if (l == r) {
cout << "! " << l << endl;
return 1;
}
const int mid = (l + r) / 2;
if (work(l, mid)) return 1;
assert(work(mid + 1, r));
return 1;
}
assert(1);
return 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (cin >> T; T--;) {
cin >> n >> k;
if (!check_1()) {
cout << "! 1" << endl;
continue;
}
for (int len = 1, l = 2, r; l <= n; l = r + 1, len <<= 1) {
r = l + len - 1;
if (r > n) r = n;
if (work(l, r)) break;
}
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const int N = 2e5 + 1;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res % MOD;
}
int gcd(int a, int b) {
while (b > 0) {
int t = a % b;
a = b, b = t;
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long is_prime(long long n) {
if (n <= 1 || n > 3 && (n % 2 == 0 || n % 3 == 0)) return 0;
for (long long i = 5, t = 2; i * i <= n; i += t, t = 6 - t)
if (n % i == 0) return 0;
return 1;
}
int modI(int a, int m) {
int m0 = m, y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m;
a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long mod_inv(long long a, long long m = MOD) {
return a == 1 ? 1 : m - mod_inv(m % a, a) * m / a;
}
long long choose(long long n, long long r) {
long long product = 1;
for (long long i = 0; i < r; i++)
product = product * (n - i) % MOD * mod_inv(i + 1) % MOD;
return product;
}
long long getcount(long long n, int k) {
long long res = (n >> (k + 1)) << k;
if ((n >> k) & 1) res += n & ((1ll << k) - 1);
return res;
}
int bit[N];
void init(void) {
int i;
for (int i = 0; i < N; i++) bit[i] = 0;
}
void update(int idx, int val) {
while (idx <= N) {
bit[idx] = max(bit[idx], val);
idx += idx & -idx;
}
}
int pref(int idx) {
int ans = 0;
while (idx > 0) {
ans = max(ans, bit[idx]);
idx -= idx & -idx;
}
return ans;
}
int dx[4] = {-1, +1, 0, 0};
int dy[4] = {0, 0, +1, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int ans[2 * n];
for (int i = 0; i < 2 * n; i++) {
char c;
cin >> c;
if (c == '+')
ans[i] = -1;
else
cin >> ans[i];
}
vector<int> temp, s;
bool fu = true;
for (int i = 2 * n - 1; i >= 0; i--) {
if (ans[i] >= 0) {
if (!s.empty() && s.back() <= ans[i])
fu = false;
else
s.push_back(ans[i]);
} else {
if (s.size() == 0)
fu = false;
else
temp.push_back(s.back()), s.pop_back();
}
}
if (fu) {
reverse((temp).begin(), (temp).end());
cout << "YES"
<< "\n";
for (int i : temp) cout << i << " ";
} else
cout << "NO"
<< "\n";
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int i, n, s1, cnt = 0;
cin >> n;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == 'A') cnt++;
}
s1 = (n - cnt);
if (cnt > s1)
cout << "Anton" << endl;
else if (cnt < s1)
cout << "Danik" << endl;
else
cout << "Friendship" << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int SIZE = 2e5 + 5;
const int INF = 1LL << 30;
const double eps = 1e-4;
const double PI = 3.1415926535897932;
long long f[200009];
long long inv[200009];
long long pw(long long a, long long b) {
if (b == 0) return 1;
long long h = pw(a, b / 2);
h = (h * h) % MOD;
if (b % 2) h = (h * a) % MOD;
return h;
}
long long choose(long long a, long long b) {
if (b < 0 || b > a) return 0;
return ((f[a] * inv[b]) % MOD * inv[a - b]) % MOD;
}
int main() {
f[0] = inv[0] = 1;
for (int i = (1); i < (SIZE); ++i) {
f[i] = (f[i - 1] * i) % MOD;
inv[i] = pw(f[i], MOD - 2);
}
int f, w, h;
scanf("%d%d%d", &f, &w, &h);
long long num = 0;
long long den = 0;
if (f == 0) {
num = (w > h);
den = 1;
} else if (w == 0) {
num = den = 1;
} else {
for (int i = (1); i < (w + 1); ++i) {
for (int j = (max(i - 1, 1)); j < (i + 2); ++j) {
long long dv = choose(w - 1, i - 1) * choose(f - 1, j - 1);
if (i == j) dv *= 2;
den = (den + dv) % MOD;
long long nv = choose((long long)w - 1 - (long long)i * h, i - 1) *
choose(f - 1, j - 1);
if (i == j) nv *= 2;
num = (num + nv) % MOD;
}
}
}
printf("%I64d", (num * pw(den, MOD - 2)) % MOD);
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[1000000], ans = 0;
char s[1000000];
void solve() {
long long an = 0, cur = 0, pos = -1;
for (int i = 0; i < n; i++)
if (s[i] == 'A') {
cur += a[i];
if (cur > an) an = cur, pos = i;
} else
cur -= a[i];
an = 0;
for (int i = 0; i <= pos; i++)
if (s[i] == 'A') an += a[i];
for (int i = pos + 1; i < n; i++)
if (s[i] == 'B') an += a[i];
ans = max(ans, an);
}
int main() {
scanf("%I64d", &n);
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
for (int i = 0; i < n; i++) cin >> s[i];
solve();
reverse(s, s + n);
reverse(a, a + n);
solve();
cout << ans;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, d, e;
int main() {
scanf("%d%d%d", &n, &d, &e);
e *= 5;
int ans = INF;
for (int i = 0; i * d <= n; i++) {
int j = (n - i * d) / e;
int tmp = i * d + j * e;
if (tmp <= n) ans = min(ans, n - tmp);
}
printf("%d\n", ans);
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 300010;
const int TINY = 1e-13;
int N;
double b[MAXN];
pair<double, int> first[MAXN];
const int MAXS = 24;
int Ls, Rs;
int L[MAXS], R[MAXS];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << setprecision(12) << fixed;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> b[i];
b[i] += i * TINY;
}
for (int i = 0; i < N; i++) first[i] = make_pair(b[i], i);
sort(first, first + N);
multiset<int> greater;
double ans = 0;
for (int i = N - 1; i >= 0; i--) {
Ls = Rs = 0;
multiset<int>::iterator it = greater.lower_bound(first[i].second);
while (it != greater.begin() && Ls < MAXS) {
it--;
L[Ls++] = *it;
}
if (Ls < MAXS) L[Ls++] = -1;
for (it = greater.upper_bound(first[i].second);
it != greater.end() && Rs < MAXS; it++)
R[Rs++] = *it;
if (Rs < MAXS) R[Rs++] = N;
int prevl = first[i].second;
double coef = 0.5;
double sa = 0;
for (int j = 0; j < Ls; j++) {
sa += coef * double(prevl - L[j]);
prevl = L[j];
coef *= 0.5;
}
int prevr = first[i].second;
coef = 1;
for (int j = 0; j < Rs; j++) {
ans += first[i].first * coef * double(R[j] - prevr) * sa;
prevr = R[j];
coef *= 0.5;
}
greater.insert(first[i].second);
}
cout << ans / (N * double(N)) << endl;
return 0;
}
| 18
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
unsigned long long maxi = 1e19;
struct node {
unsigned long long x, k;
int s;
} a[100];
unsigned long long dp[(1 << 20)], b;
bool cmp(node u, node v) { return u.k < v.k; }
unsigned long long ans = maxi;
int n, m;
int main() {
cin >> n >> m >> b;
int t, len;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].k >> len;
a[i].k *= b;
for (int j = 0; j < len; j++) {
cin >> t;
a[i].s |= (1 << (t - 1));
}
}
sort(a, a + n, cmp);
for (int i = 1; i < (1 << m); i++) dp[i] = maxi;
for (int i = 0; i < n; i++) {
for (int j = (1 << m) - 1;; j--) {
dp[j | a[i].s] = min(dp[j | a[i].s], dp[j] + a[i].x);
if (j == 0) break;
}
if (dp[(1 << m) - 1] < maxi) ans = min(ans, dp[(1 << m) - 1] + a[i].k);
}
if (ans == maxi)
cout << -1;
else
cout << ans;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int arr[1010], n, m, k, i, j, in, res;
int main() {
scanf(" %d %d", &n, &m);
res = 0;
for (i = 1; i <= n; i++) {
scanf(" %d", &k);
for (j = 1; j <= k; j++) {
scanf(" %d", &in);
if (arr[in] == 0) {
arr[in] = 1;
res++;
}
}
}
if (res == m)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a, i, cnt[11] = {0};
for (i = 0; i < n; i++) {
cin >> a;
cnt[a]++;
}
long long ans = ((long long)n * (n + 1)) / 2;
for (i = 0; i <= m; i++) {
ans = ans - ((long long)cnt[i] * (1 + cnt[i])) / 2;
}
cout << ans << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
void make_cycle(long long m, long long& sum_cycle, vector<long long>& arr,
long long& divider) {
sum_cycle = 0;
if (m && 1) {
arr.resize(11);
arr[0] = 0;
divider = m * 10LL;
for (long long i = 1; i <= 10; i++) {
arr[i] = (m * i) % 10;
sum_cycle += arr[i];
}
} else {
arr.resize(6);
arr[0] = 0;
divider = m * 5LL;
for (long long i = 1; i <= 5; i++) {
arr[i] = (m * i) % 10;
sum_cycle += arr[i];
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
long long n;
long long m;
long long divider;
cin >> n >> m;
long long sum_cycle = 0;
vector<long long> arr;
make_cycle(m, sum_cycle, arr, divider);
long long sum_t = (n / divider) * sum_cycle;
long long remdig = (n % divider) / m;
for (int i = 1; i <= remdig; i++) {
sum_t += arr[i];
}
cout << sum_t << endl;
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int fre[26];
int main() {
int tc = 1;
cin >> tc;
while (tc--) {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < s[i].size(); j++) {
fre[s[i][j] - 'a']++;
}
}
bool pos = true;
for (int i = 0; i < 26; i++) {
if (fre[i] % n != 0) pos = false;
}
if (pos == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
for (int i = 0; i < 26; i++) fre[i] = 0;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100032;
const double EPS = 1e-10;
struct point {
long long x, y, id;
void print() { cout << x << " " << y << endl; }
};
point P[MAX], C[MAX], P0;
inline long long triArea2(const point &a, const point &b, const point &c) {
return (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
}
inline long long sqDist(const point &a, const point &b) {
return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
inline double dist(const point &a, const point &b) {
return hypot((double)(a.x - b.x), (double)(a.y - b.y));
}
inline bool comp(const point &a, const point &b) {
long long d = triArea2(P0, a, b);
if (d < 0) return false;
if (!d && sqDist(P0, a) > sqDist(P0, b)) return false;
return true;
}
inline bool normal(const point &a, const point &b) {
return ((a.x == b.x) ? a.y < b.y : a.x < b.x);
}
inline bool issame(const point &a, const point &b) {
return (a.x == b.x && a.y == b.y);
}
inline void makeUnique(int &np) {
sort(P, P + np, normal);
np = unique(P, P + np, issame) - P;
}
void convexHull(int &np, int &nc) {
int i, j, pos = 0;
for (i = 1; i < np; i++)
if (P[i].y < P[pos].y || (P[i].y == P[pos].y && P[i].x < P[pos].x)) pos = i;
swap(P[0], P[pos]);
P0 = P[0];
sort(&P[1], &P[np], comp);
for (i = 0; i < 3; i++) C[i] = P[i];
for (i = j = 3; i < np; i++) {
while (triArea2(C[j - 2], C[j - 1], P[i]) < 0) j--;
C[j++] = P[i];
}
nc = j;
}
void compress(int &nc) {
int i, j;
long long d;
for (i = j = 1; i < nc; i++) {
d = triArea2(C[j - 1], C[i], C[i + 1]);
if (d || (!d && C[j - 1].id == C[i + 1].id)) C[j++] = C[i];
}
nc = j;
}
long long val(long long p, long long q, point r) { return r.x * q - r.y * p; }
int main() {
int n, p, q;
cin >> n >> p >> q;
long long mxa, mxb;
mxa = mxb = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> P[i].x >> P[i].y;
mxa = max(mxa, P[i].x);
mxb = max(mxb, P[i].y);
}
P[n].x = mxa, P[n++].y = 0;
P[n].x = 0, P[n++].y = mxb;
P[n].x = 0, P[n++].y = 0;
for (int i = 0; i < n; i++) P[i].id = i + 1;
makeUnique(n);
int nc;
convexHull(n, nc);
C[nc] = C[0];
point zr;
zr.x = zr.y = 0;
double ax;
for (int i = 0; i < nc; i++) {
if (issame(C[i], zr) || issame(C[i + 1], zr)) continue;
long long x = val(p, q, C[i]);
long long y = val(p, q, C[i + 1]);
if (x == 0) {
ax = C[i].x;
break;
}
if (y == 0) {
ax = C[i + 1].x;
break;
}
if (x > 0 && y > 0) {
continue;
}
if (x < 0 && y < 0) continue;
double x1, y1, x2, y2;
x1 = C[i].x, y1 = C[i].y, x2 = C[i + 1].x, y2 = C[i + 1].y;
double t = (y2 * p - x2 * q) / ((x1 - x2) * q - (y1 - y2) * p);
ax = x1 * t + (1 - t) * x2;
}
double ans = p / ax;
printf("%.10f\n", ans);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > v;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= min(n, m); i++) v.push_back(make_pair(i, min(n, m) - i));
printf("%d\n", v.size());
for (int i = 0; i < v.size(); i++) printf("%d %d\n", v[i].first, v[i].second);
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int a[7];
int main() {
for (int i = 0; i < 6; ++i) scanf("%d", a + i);
int p1(min(a[5], a[1]));
int p2(max(a[5], a[1]));
int p3(a[2] + a[1]);
int s(0);
int nl(a[0]);
for (int i = 0; i < p1; ++i) {
s += nl * 2 + 1;
nl++;
}
for (int i = p1; i < p2; ++i) s += nl * 2;
for (int i = p2; i < p3; ++i) {
s += nl * 2 - 1;
nl--;
}
printf("%d\n", s);
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
register int data = 0, w = 1;
register char ch = 0;
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) data = 10 * data + ch - '0', ch = getchar();
return w * data;
}
const int Mod = 1e9 + 7;
const int INF = 1e9;
const int MAX_N = 2e5 + 5;
struct Graph {
int to, cost, next;
} e[MAX_N << 2];
int fir[MAX_N], deg[MAX_N], e_cnt;
void clearGraph() {
memset(fir, -1, sizeof(fir));
e_cnt = 0;
}
void Add_Edge(int u, int v, int w) {
e[e_cnt] = (Graph){v, w, fir[u]}, fir[u] = e_cnt++, deg[v]++;
}
int N;
pair<int, int> p[MAX_N];
int dis[MAX_N], cnt[MAX_N];
void TopSort() {
static queue<int> que;
for (int i = 1; i <= N; i++) dis[i] = INF;
cnt[0] = 1, que.push(0);
while (!que.empty()) {
int x = que.front();
que.pop();
for (int i = fir[x]; ~i; i = e[i].next) {
int v = e[i].to, w = e[i].cost;
if (!--deg[v]) que.push(v);
if (dis[x] + w < dis[v])
dis[v] = dis[x] + w, cnt[v] = cnt[x];
else if (dis[x] + w == dis[v])
cnt[v] = (cnt[v] + cnt[x]) % Mod;
}
}
}
int main() {
N = gi();
for (int i = 1; i <= N; i++) p[i].second = gi(), p[i].first = gi();
sort(&p[1], &p[N + 1]);
clearGraph();
for (int i = 1; i <= N; i++) Add_Edge(i - 1, i, p[i].first - p[i - 1].first);
for (int i = 1; i <= N; i++) {
int j = lower_bound(&p[i + 1], &p[N + 1], make_pair(p[i].second, 0)) - p;
Add_Edge(i, j, p[j].first - p[i].second);
}
TopSort();
int mdis = INF;
for (int i = 1; i <= N; i++)
if (p[i].second > p[N].first) mdis = min(mdis, dis[i]);
int ans = 0;
for (int i = 1; i <= N; i++)
if (p[i].second > p[N].first && mdis == dis[i]) ans = (ans + cnt[i]) % Mod;
printf("%d\n", ans);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 2e5 + 5;
const int32_t maxn = N;
template <typename NODE, typename UPDATE>
struct segtree {
bool built = false, lazy[4 * maxn];
NODE zero = NODE(), t[4 * maxn];
UPDATE noop = UPDATE(), upds[4 * maxn];
int32_t tl[4 * maxn], tr[4 * maxn];
inline void pushdown(int32_t v) {
if (lazy[v]) {
apply(v * 2, upds[v]);
apply(v * 2 + 1, upds[v]);
lazy[v] = 0;
upds[v] = noop;
}
}
inline void apply(int32_t v, UPDATE &val) {
if (tl[v] != tr[v]) {
lazy[v] = 1;
upds[v].combine(val, tl[v], tr[v]);
}
val.apply(t[v], tl[v], tr[v]);
}
template <typename T>
void build(T a, int32_t v, int32_t l, int32_t r) {
tl[v] = l;
tr[v] = r;
if (l == r) {
t[v] = a[l];
return;
} else {
int32_t tm = (l + r) / 2;
build(a, v * 2, l, tm);
build(a, v * 2 + 1, tm + 1, r);
t[v].merge(t[v * 2], t[v * 2 + 1]);
}
}
NODE query(int32_t v, long long l, long long r) {
if (l > tr[v] || r < tl[v]) return zero;
if (l <= tl[v] && tr[v] <= r) {
return t[v];
}
pushdown(v);
NODE a, b, ans;
a = query(v * 2, l, r);
b = query(v * 2 + 1, l, r);
ans.merge(a, b);
return ans;
}
void rupd(int32_t v, long long l, long long r, UPDATE &val) {
if (l > tr[v] || r < tl[v]) return;
if (l <= tl[v] && tr[v] <= r) {
apply(v, val);
return;
}
pushdown(v);
rupd(v * 2, l, r, val);
rupd(v * 2 + 1, l, r, val);
t[v].merge(t[v * 2], t[v * 2 + 1]);
}
template <typename T>
long long descent_right(long long l, T x, int32_t v, NODE &prev) {
if (l > tr[v]) return len;
if (l <= tl[v]) {
NODE cur;
cur.merge(prev, t[v]);
if (!cur.check(x)) {
swap(prev, cur);
return len;
}
if (tl[v] == tr[v]) {
return tr[v];
}
}
pushdown(v);
long long ans = descent_right(l, x, v * 2, prev);
if (ans != len) return ans;
return descent_right(l, x, v * 2 + 1, prev);
}
template <typename T>
long long descent_left(long long r, T x, int32_t v, NODE &prev) {
if (r < tl[v]) return -1;
if (r >= tr[v]) {
NODE cur;
cur.merge(t[v], prev);
if (!cur.check(x)) {
swap(cur, prev);
return -1;
}
if (tl[v] == tr[v]) {
return tl[v];
}
}
pushdown(v);
long long ans = descent_left(r, x, v * 2 + 1, prev);
if (ans != -1) return ans;
return descent_left(r, x, v * 2, prev);
}
long long len = maxn;
void clear() {
fill(t, t + 4 * len, zero);
fill(lazy, lazy + 4 * len, false);
fill(upds, upds + 4 * len, noop);
}
template <typename T>
void build(T a) {
build(a, 1, 0, len - 1);
built = true;
}
template <typename T>
long long descent_right(long long l, T x) {
NODE prev = zero;
return descent_right(l, x, 1, prev);
}
template <typename T>
long long descent_left(long long r, T x) {
NODE prev = zero;
return descent_left(r, x, 1, prev);
}
NODE query(long long l, long long r) {
if (!built) build(t);
return query(1, l, r);
}
void rupd(long long l, long long r, UPDATE val) {
if (!built) build(t);
rupd(1, l, r, val);
}
};
struct node1 {
long long v = -INF;
node1() {}
node1(long long val) { v = val; }
void merge(node1 &l, node1 &r) { v = max(l.v, r.v); }
bool check(long long x) { return false; }
};
struct update1 {
long long v = 0;
update1() {}
update1(long long val) { v = val; }
void combine(update1 &other, int32_t tl, int32_t tr) {}
void apply(node1 &x, int32_t tl, int32_t tr) { x.v = v; }
};
segtree<node1, update1> tmx;
segtree<node1, update1> tmn;
long long a[N];
long long dp[N][2];
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (i) a[i] += a[i - 1];
}
for (long long i = n - 1; i >= 0; i--) {
if (i == n - 1) {
dp[i][0] = dp[i][1] = 0;
} else {
dp[i][0] = tmx.query(i + 1, n - 1).v;
dp[i][1] = -tmn.query(i + 1, n - 1).v;
}
tmn.rupd(i, i, a[i] - dp[i][0]);
tmx.rupd(i, i, dp[i][1] + a[i]);
}
cout << dp[0][0];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int f[18][200005];
int x[200005], y[200005], c[200005], dep[200005];
vector<int> G[200005], E[200005];
int Lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
for (int i = 0; dep[y] > dep[x]; i++)
if (dep[y] - dep[x] >> i & 1) y = f[i][y];
if (x == y) return x;
for (int i = 18 - 1; i >= 0; i--)
if (f[i][x] != f[i][y]) x = f[i][x], y = f[i][y];
return f[0][x];
}
int F[200005], g[200005], s[200005], h[200005];
int Find(int u) {
if (!F[u]) return u;
int t = F[u];
F[u] = Find(t);
if (F[u] ^ t) g[u] += g[t];
return F[u];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; i++)
scanf("%d", &f[0][i]), dep[i] = dep[f[0][i]] + 1, E[f[0][i]].push_back(i);
for (int j = 1; j < 18; j++)
for (int i = 1; i <= n; i++) f[j][i] = f[j - 1][f[j - 1][i]];
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &x[i], &y[i], &c[i]), G[Lca(x[i], y[i])].push_back(i);
for (int i = n; i >= 1; i--) {
int t = 0;
for (int j = 0; j < E[i].size(); j++) F[E[i][j]] = i;
for (int j = 0; j < G[i].size(); j++) {
Find(x[G[i][j]]), Find(y[G[i][j]]);
t = max(t, c[G[i][j]] + g[x[G[i][j]]] + g[y[G[i][j]]]);
}
for (int j = 0; j < E[i].size(); j++) s[i] += h[E[i][j]];
h[i] = t + s[i];
g[i] = s[i] - h[i];
}
printf("%d\n", h[1]);
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 1e6 + 10;
int N;
vector<pair<int, int> > e[SIZE];
long long dp[SIZE][2], num[SIZE];
void dfs1(int x, int lt) {
num[x] = 1;
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i].first;
if (y == lt) continue;
dfs1(y, x);
num[x] += num[y];
dp[x][0] += dp[y][0] + num[y];
}
}
void dfs2(int x, int lt, long long v) {
dp[x][1] = dp[x][0] + v;
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i].first;
if (y == lt) continue;
dfs2(y, x, v + (dp[x][0] - dp[y][0] - num[y]) + (N - num[y]));
}
}
void add(int x, int y, int v) {
e[x].push_back(make_pair(y, v));
e[y].push_back(make_pair(x, v));
}
int jump[20][SIZE], lv[SIZE];
void __init(int x, int lt) {
jump[0][x] = lt;
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i].first;
if (y != lt) {
lv[y] = lv[x] + 1;
__init(y, x);
}
}
}
int adv(int x, int v) {
for (int i = 0; (1 << i) <= v; i++) {
if ((v >> i) & 1) x = jump[i][x];
}
return x;
}
int lca(int x, int y) {
if (lv[x] > lv[y])
x = adv(x, lv[x] - lv[y]);
else
y = adv(y, lv[y] - lv[x]);
if (x == y) return x;
for (int i = 19; i >= 0; i--)
if (jump[i][x] != jump[i][y]) {
x = jump[i][x];
y = jump[i][y];
}
return jump[0][x];
}
void build(int root) {
__init(root, root);
for (int i = (1); i < (20); ++i) {
for (int x = (1); x < (N + 1); ++x)
jump[i][x] = jump[i - 1][jump[i - 1][x]];
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
N = n;
for (int i = (1); i < (n); ++i) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y, 1);
}
build(1);
dfs1(1, 1);
dfs2(1, 1, 0);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
if (lv[x] > lv[y]) swap(x, y);
int z = lca(x, y);
if (z != x) {
printf("%.12f\n", lv[x] + lv[y] - lv[z] * 2 + (dp[x][0] * 1. / num[x]) +
dp[y][0] * 1. / num[y] + 1);
} else {
int u = adv(y, lv[y] - lv[x] - 1);
printf("%.12f\n", lv[y] - lv[x] + (dp[y][0] * 1. / num[y]) +
(dp[x][1] - dp[u][0] - num[u]) * 1. / (N - num[u]) +
1);
}
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void doit() {
long long n, k, i, x;
cin >> n >> k;
deque<long long> dq;
unordered_map<long long, long long, custom_hash> mp;
for (i = 0; i < n; i++) {
cin >> x;
if (mp.find(x) != mp.end()) continue;
mp[x] = 1;
if (dq.size() < k) {
dq.push_front(x);
} else {
mp.erase(dq.back());
dq.pop_back();
dq.push_front(x);
}
}
cout << dq.size() << "\n";
while (!dq.empty()) {
cout << dq.front() << " ";
dq.pop_front();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
for (long long i = 1; i <= t; i++) {
doit();
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
template <class T1>
inline void read(T1 &);
template <class T1>
inline void write(T1);
int s[10005];
int b[10005];
int main() {
int t;
read(t);
while (t--) {
int n;
double mini = 100000000000;
int ansa, ansb;
read(n);
memset(s, 0, sizeof(s));
for (int i = 1; i <= n; i++) {
int a;
read(a);
s[a]++;
}
int id = 0;
for (int i = 1; i <= 10000; i++) {
if (s[i] >= 2) {
b[++id] = i;
}
if (s[i] >= 4) {
b[++id] = i;
}
}
for (int i = 1; i < id; i++) {
double now = (b[i] * 1.0 / b[i + 1]) + (b[i + 1] * 1.0 / b[i]);
if (now < mini) {
mini = now;
ansa = b[i];
ansb = b[i + 1];
}
}
write(ansa);
putchar(' ');
write(ansa);
putchar(' ');
write(ansb);
putchar(' ');
write(ansb);
putchar('\n');
}
return 0;
}
template <class T1>
void read(T1 &r_e_a_d) {
T1 k = 0;
char ch = getchar();
int flag = 1;
while (!(ch >= '0' && ch <= '9')) {
if (ch == '-') {
flag = -1;
}
ch = getchar();
}
while ((ch >= '0' && ch <= '9')) {
k = (k << 1) + (k << 3) + ch - '0';
ch = getchar();
}
r_e_a_d = flag * k;
}
template <class T1>
void write(T1 w_r_i_t_e) {
if (w_r_i_t_e < 0) {
putchar('-');
write(-w_r_i_t_e);
} else {
if (w_r_i_t_e < 10) {
putchar(w_r_i_t_e + '0');
} else {
write(w_r_i_t_e / 10);
putchar((w_r_i_t_e % 10) + '0');
}
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
long double PI = 3.14159265358979323846;
long long modo = 1e9 + 7;
const long long inf = 1e13;
const long long ms = (1e5) * 2 + 5;
vector<int> vv[101];
int vis[101];
void dfs(int node) {
vis[node] = 1;
for (int i : vv[node]) {
if (!vis[i]) dfs(i);
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n;
cin >> n;
int ar[n + 1][2];
int i;
int j;
for (i = 1; i <= n; i++) {
cin >> ar[i][0] >> ar[i][1];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i != j) {
if (ar[i][0] == ar[j][0] || ar[i][1] == ar[j][1]) {
vv[i].push_back(j);
}
}
}
}
int ans = -1;
for (i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
ans++;
}
}
cout << ans;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
bitset<350000001> b;
int ss[20000000];
int cnt;
void makeprime(int n) {
for (int i = 2; i <= n; ++i) {
if (!b[i]) cnt++, ss[cnt] = i;
for (int j = 1; j <= cnt && ss[j] * i <= n; ++j) {
b[i * ss[j]] = 1;
if (i % ss[j] == 0) break;
}
}
}
int main() {
int l, r;
cin >> l >> r;
makeprime(r);
int tot = 0;
b[1] = 1;
for (int i = l; i <= r; ++i)
if (b[i] == 0 && (i % 4 == 1 || i == 2)) tot++;
cout << tot << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
string s[maxn];
int n, t;
int main() {
for (scanf("%d", &t); t--;) {
int ans = 0;
vector<int> vec[5];
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
cin >> s[i];
int num[5] = {0};
for (auto j : s[i]) num[j - 'a']++;
for (int j = 0; j < 5; ++j)
vec[j].emplace_back((num[j] << 1) - s[i].size());
}
for (int i = 0; i < 5; ++i) {
sort(vec[i].begin(), vec[i].end());
reverse(vec[i].begin(), vec[i].end());
int cnt = 0, now = 0;
for (auto j : vec[i])
if (now + j <= 0)
break;
else
++cnt, now += j;
ans = max(ans, cnt);
}
printf("%d\n", ans);
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[200010];
int pos[200010], idx[200010], mp[200010];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &p[i].first), p[i].second = i;
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++)
pos[i] = p[i].first, idx[i] = p[i].second, mp[p[i].second] = i;
while (m--) {
bool type = true;
int x, len;
scanf("%d%d", &x, &len);
if (n == 1) {
printf("1\n");
continue;
}
x = mp[x];
int id = upper_bound(pos + 1, pos + n + 1, pos[x] + len) - pos - 1;
len -= pos[id] - pos[x];
x = id;
type = false;
if (len >= pos[n] - pos[1]) {
int q = len / (pos[n] - pos[1]);
if (q % 2)
x = 1, type = true;
else
x = n, type = false;
len -= q * (pos[n] - pos[1]);
}
while (len) {
if (type) {
id = upper_bound(pos + 1, pos + n + 1, pos[x] + len) - pos - 1;
if (id == x || pos[id] == pos[x] + len) {
x = id;
break;
}
if (pos[id] - pos[x] >= len / 2) {
len -= (pos[id] - pos[x]);
x = id;
type = !type;
continue;
}
int tmp = pos[id] - pos[x], q = len / tmp;
if (q % 2)
x = id, type = false, len -= q * tmp;
else
len -= q * tmp;
} else {
id = lower_bound(pos + 1, pos + n + 1, pos[x] - len) - pos;
if (id == x || pos[id] == pos[x] - len) {
x = id;
break;
}
if (pos[x] - pos[id] >= len / 2) {
len -= (pos[x] - pos[id]);
x = id;
type = !type;
continue;
}
int tmp = (pos[x] - pos[id]), q = len / tmp;
if (q % 2)
x = id, type = true, len -= q * tmp;
else
len -= q * tmp;
}
}
printf("%d\n", idx[x]);
}
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<int> r(n + 1, 0), c(m + 1, 0);
vector<int> tr(n + 1, 0), tc(m + 1, 0);
for (int i = 1; i <= k; i++) {
int t, x, a;
cin >> t >> x >> a;
if (t == 1) {
r[x] = a;
tr[x] = i;
} else {
c[x] = a;
tc[x] = i;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (r[i] == c[j])
printf("%d ", r[i]);
else if (tr[i] > tc[j])
printf("%d ", r[i]);
else
printf("%d ", c[j]);
}
printf("\n");
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[100000], *p1 = buf + 100000, *pend = buf + 100000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 100000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(long long &x) {
char ch;
long long f = 1;
while (blank(ch = nc()))
;
while (ch == '-') f = -f, ch = nc();
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
x *= f;
}
inline void read(int &x) {
char ch;
int f = 1;
while (blank(ch = nc()))
;
while (ch == '-') f = -f, ch = nc();
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
x *= f;
}
inline void read(char *s) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
int i = 0;
for (; !blank(ch); s[i++] = ch, ch = nc())
;
s[i] = '\0';
}
}; // namespace fastIO
using namespace fastIO;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct edge {
int to, next, mrk;
} e[400010];
int n, m, cnt = 1;
int head[200010];
int dep[200010];
int ans, ansx[200010], ansy[200010], ansz[200010];
bool mrk[200010];
inline void add(int x, int y, int z) {
ans++;
ansx[ans] = x;
ansy[ans] = y;
ansz[ans] = z;
}
inline void dfs(int x, int fa, int d, int lnk) {
vector<int> now;
mrk[x] = 1;
dep[x] = d;
for (int i = head[x]; i; i = e[i].next) {
if (!mrk[e[i].to]) {
dfs(e[i].to, x, d + 1, i ^ 1);
if (!e[i].mrk) now.push_back(i);
} else if (dep[x] > dep[e[i].to] && fa != e[i].to)
now.push_back(i);
}
if ((now.size() & 1) && fa != -1) now.push_back(lnk);
int mx = now.size(), xx, yy;
for (int i = 0; i + 1 < mx; i += 2) {
xx = e[now[i]].to;
yy = e[now[i + 1]].to;
add(xx, x, yy);
e[now[i]].mrk = e[now[i] ^ 1].mrk = 1;
e[now[i + 1]].mrk = e[now[i + 1] ^ 1].mrk = 1;
}
}
inline void ins(int u, int v) {
e[++cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
e[cnt].mrk = 0;
}
inline void insert(int u, int v) {
ins(v, u);
ins(u, v);
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
insert(x, y);
}
for (int i = 1; i <= n; i++)
if (!mrk[i]) dfs(i, -1, 0, -1);
printf("%d\n", ans);
for (int i = 1; i <= ans; i++)
printf("%d %d %d\n", ansx[i], ansy[i], ansz[i]);
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a = 8;
cin >> n;
if (n > 1) {
n = (n - 1) % 4;
n++;
}
switch (n) {
case 0:
cout << 1;
break;
case 1:
cout << 8;
break;
case 2:
cout << 4;
break;
case 3:
cout << 2;
break;
case 4:
cout << 6;
break;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
struct node {
int v, nxt;
} e[N * 2];
int head[N], ejs;
void add(int u, int v) {
e[++ejs].v = v;
e[ejs].nxt = head[u];
head[u] = ejs;
}
int a[N], fa[N];
int dep[N], vis[N];
queue<int> q;
inline void bfs(int u) {
dep[u] = 0;
q.push(u);
vis[u] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (vis[v]) continue;
dep[v] = dep[u] + 1;
vis[v] = 1;
fa[v] = u;
q.push(v);
}
}
}
int pos[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
bfs(1);
int now = 0, fanow = 0;
for (int i = 1; i <= n; ++i) {
if (dep[a[i]] < now || pos[fa[a[i]]] < fanow) {
printf("NO\n");
return 0;
}
if (dep[a[i]] > now) now = dep[a[i]];
fanow = pos[fa[a[i]]];
}
printf("YES\n");
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v[3000];
char c[3000][3000];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> c[i][j];
if (c[i][j] == '1') {
v[j].push_back(i);
}
}
}
bool res = 0;
int al = 0;
for (int s = 0; s < n; ++s) {
al = 0;
for (int l = 0; l < m; ++l) {
if (v[l].size() == 1 && v[l][0] == s) continue;
al++;
}
if (al == m) res = 1;
}
if (res)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
long long int n, m;
cin >> n >> m;
long long int cnt = 0;
if (n <= 1 and m <= 1) return (cout << 0, 0);
while (1) {
cnt++;
if (n < m) {
n++;
m -= 2;
} else {
m++;
n -= 2;
}
if (n <= 0 or m <= 0) break;
}
cout << cnt;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
string p;
int tam, pos;
int cambios[1000006], res;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> p;
tam = p.size();
reverse(p.begin(), p.end());
for (int i = 0; i < tam; i++) {
if (p[i] == '0') continue;
pos = i;
cambios[i] = 1;
while (p[pos] == '1') pos++;
if (pos - i >= 2) {
cambios[i] = -1;
for (int j = i + 1; j <= pos - 1; j++) cambios[j] = 0;
p[pos] = '1';
cambios[pos] = 1;
}
i = pos - 1;
}
for (int i = 0; i <= tam; i++)
if (cambios[i] != 0) res++;
printf("%d\n", res);
for (int i = 0; i <= tam; i++) {
if (cambios[i] == 1)
printf("+2^%d\n", i);
else if (cambios[i] == -1)
printf("-2^%d\n", i);
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int lis[2003][2003];
int ps1[2003];
int ps2[2003];
int main() {
int n;
int v[2003];
scanf("%d", &n);
int qt1 = 0, qt2 = 0;
int p1 = -1;
for (int i = 0; i < n; i++) {
scanf("%d", v + i);
if (v[i] == 1) {
if (p1 == -1) {
p1 = i;
}
qt1++;
} else {
qt2++;
}
}
int ans = max(qt1, qt2);
if (p1 == -1) {
printf("%d\n", ans);
return 0;
}
for (int i = 0; i < n; i++) {
if (v[i] == 1) {
int aux = 1;
reverse(v, v + i + 1);
for (int j = 0; j < n; j++) {
ps1[j] = v[j] == 1;
ps2[j] = v[j] == 2;
if (j) {
ps1[j] += ps1[j - 1];
ps2[j] += ps2[j - 1];
}
}
for (int j = 1; j < n; j++) {
aux = max(aux, ps1[j] + (ps2[n - 1] - ps2[j - 1]));
}
ans = max(ans, aux);
reverse(v, v + i + 1);
}
}
for (int j = 0; j < n; j++) {
ps1[j] = v[j] == 1;
ps2[j] = v[j] == 2;
if (j) {
ps1[j] += ps1[j - 1];
ps2[j] += ps2[j - 1];
}
}
for (int i = p1; i < n; i++) {
ans = max(ans, ps1[i] + (ps2[n - 1] - (i ? ps2[i - 1] : 0)));
}
for (int i = n - 1; i >= 0; i--) {
int l1 = 0;
int l2 = 0;
lis[i][i] = 1;
if (v[i] == 1) l1 = 1;
for (int j = i - 1; j >= 0; j--) {
lis[i][j] = lis[i][j + 1];
if (v[j] == 1) {
l1++;
lis[i][j] = max(lis[i][j], l1);
}
if (v[j] == 2) {
lis[i][j]++;
}
}
}
for (int i = p1 + 1; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans = max(ans, lis[j][i] + ps1[i - 1] + (ps2[n - 1] - ps2[j]));
}
}
printf("%d\n", ans);
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
template <class T>
inline void read(T &x) {
x = 0;
int f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = f ? -x : x;
}
struct edge {
int next, to;
} e[N << 1];
int t, T, n, m, cnt, head[N], l[N], r[N], co[N], n1 = 0x3f3f3f3f, n2;
inline void add(int u, int v) {
e[++cnt] = {head[u], v};
head[u] = cnt;
}
void dfs(int x) {
for (int i = head[x]; i; i = e[i].next) {
int y = e[i].to;
if (!co[y])
co[y] = 3 - co[x], dfs(y);
else if (co[y] == co[x])
puts("IMPOSSIBLE"), exit(0);
}
}
int main() {
read(t), read(T), read(n), read(m);
for (int i = 1; i <= n; i++)
read(l[i]), read(r[i]), n1 = min(n1, r[i]), n2 = max(n2, l[i]);
for (int i = 1; i <= m; i++) {
int u, v;
read(u), read(v);
add(u, v), add(v, u);
}
if (n1 + n2 < t) n2 = t - n1;
if (n1 + n2 > T) n1 = T - n2;
if (n1 < 0 || n2 < 0) return puts("IMPOSSIBLE"), 0;
for (int i = 1; i <= n; i++)
if (l[i] <= n1 && r[i] >= n1 && (l[i] > n2 || r[i] < n2))
co[i] = 1;
else if (l[i] <= n2 && r[i] >= n2 && (l[i] > n1 || r[i] < n1))
co[i] = 2;
else if ((l[i] > n1 || r[i] < n1) && (l[i] > n2 || r[i] < n2))
return puts("IMPOSSIBLE"), 0;
for (int i = 1; i <= n; i++)
if (co[i]) dfs(i);
for (int i = 1; i <= n; i++)
if (!co[i]) co[i] = 1, dfs(i);
puts("POSSIBLE");
printf("%d %d\n", n1, n2);
for (int i = 1; i <= n; i++) (co[i] - 1) ? putchar('2') : putchar('1');
return 0;
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
int n, k;
int Pow10[10], F[10];
long long f[N];
long long cal(int n) {
int t = 0;
long long s = 0;
while (n > 0) {
int x = n % 10;
if (x % 3 == 0) s += 1LL * F[t] * x / 3;
n /= 10;
t++;
}
return s;
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("main.in", "r")) freopen("main.in", "r", stdin);
cin >> k;
Pow10[0] = 1;
for (int i = 0; i < 6; i++) {
cin >> F[i];
if (i) Pow10[i] = Pow10[i - 1] * 10;
}
for (int i = 0; i <= N - 2; i++) f[i] = -1e15;
f[0] = 0;
for (int t = 0; t < 6; t++) {
int s = 0, p = 1;
while (s + p <= 3 * (k - 1)) {
s += p;
for (int i = N - 2; i >= 3LL * p * Pow10[t]; i--)
f[i] = max(f[i], f[i - 3 * p * Pow10[t]] + 1LL * p * F[t]);
p *= 2;
}
s = 3 * (k - 1) - s;
for (int i = N - 2; i >= 3LL * s * Pow10[t]; i--)
f[i] = max(f[i], f[i - 3 * s * Pow10[t]] + 1LL * s * F[t]);
}
for (int t = 0; t < 6; t++) {
for (int i = N - 2; i >= 0; i--)
for (int j = 0; j <= 9; j++) {
if (i < j * Pow10[t]) continue;
long long bonus = (j % 3 == 0) ? 1LL * j / 3 * F[t] : 0;
f[i] = max(f[i], f[i - j * Pow10[t]] + bonus);
}
}
int _;
cin >> _;
while (_--) {
int n;
cin >> n;
cout << f[n] << '\n';
}
return 0;
}
| 22
|
#include <bits/stdc++.h>
const int maxn = 1e6 + 5;
char a[maxn];
long long b[maxn][3];
int main() {
scanf("%s", a);
int len = strlen(a);
for (int i = 0; i < len; i++) {
if (a[i] == 'o')
b[i][0] = 0;
else
b[i][0] = 1;
}
int lw = 0, rw = 0;
for (int i = 1; i < len; i++) {
if (b[i - 1][0] == 1 && b[i][0] == 1) lw++;
if (b[i][0] == 0) b[i][1] = lw;
}
for (int i = len - 2; i >= 0; i--) {
if (b[i + 1][0] == 1 && b[i][0] == 1) rw++;
if (b[i][0] == 0) b[i][2] = rw;
}
long long res = 0;
for (int i = 0; i < len; i++) {
if (b[i][0] == 0) res += b[i][1] * b[i][2];
}
printf("%lld\n", res);
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int GOD = 55;
int N, M;
char a[GOD][GOD];
bool good;
bool was[GOD][GOD];
int dirX[] = {0, 0, -1, 1};
int dirY[] = {1, -1, 0, 0};
bool within(int p, int q) { return p >= 0 && q >= 0 && p < N && q < M; }
bool dfs(int x, int y, int px, int py, char c) {
was[x][y] = true;
for (int i = 0; i < 4; i++) {
int new_X = x + dirX[i];
int new_Y = y + dirY[i];
if (new_X == px && new_Y == py) continue;
if (within(new_X, new_Y) && a[new_X][new_Y] == c) {
if (was[new_X][new_Y]) return true;
if (dfs(new_X, new_Y, x, y, c)) return true;
}
}
return false;
}
int main() {
cin >> N >> M;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) cin >> a[i][j];
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
if (was[i][j] == false)
if (dfs(i, j, -1, -1, a[i][j])) good = true;
printf((good) ? "Yes\n" : "No\n");
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int a[16];
int main() {
int n, k;
int t, mi, z;
while (~scanf("%d %d", &n, &k)) {
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
t = 0, mi = 1 << (k - 1);
for (int j = 0; j < k; j++) {
scanf("%d", &z);
t += z * mi;
mi /= 2;
}
a[t]++;
}
bool flag = false;
for (int i = 0; i < (1 << k); i++) {
if (a[i] != 0) {
for (int j = 0; j < (1 << k); j++) {
if (a[j] != 0 && ((i & j) == 0)) {
flag = true;
printf("YES\n");
break;
}
}
}
if (flag) break;
}
if (!flag) printf("NO\n");
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c;
cin >> n >> m >> c;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int b[m + 1];
b[0] = 0;
for (int i = 1; i <= m; i++) {
cin >> b[i];
b[i] += b[i - 1];
}
for (int i = 0; i < n; i++) {
cout << (a[i] + b[min(i + 1, m)] - b[max(i - (n - m), 0)]) % c << ' ';
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
void test_case() {
long long n;
scanf("%lld", &n);
priority_queue<int> nums;
for (long long i = 1; i <= n; i++) {
nums.push(i);
}
puts("2");
for (int i = 1; i < n; i++) {
float b = nums.top();
nums.pop();
float a = nums.top();
nums.pop();
int res = ceil((a + b) / 2);
nums.push(res);
printf("%d %d\n", (int)a, (int)b);
}
}
int main() {
long long T;
scanf("%lld", &T);
while (T--) {
test_case();
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
getline(cin, a);
for (int i = a.size() - 1; i > -1; i--) {
if (isalpha(a[i])) {
a[i] = toupper(a[i]);
if (a[i] == 'A' or a[i] == 'E' or a[i] == 'I' or a[i] == 'O' or
a[i] == 'U' or a[i] == 'Y') {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ans = 0, t[n];
for (int i = 0; i < n; i++) scanf("%d", &t[i]), ans += t[i];
for (int i = 2; i <= n / 3; i++)
if (n % i == 0)
for (int j = 0; j < i; j++) {
int s = 0;
for (int k = j; k < n; k += i) s += t[k];
if (s > ans) ans = s;
}
printf("%d\n", ans);
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, maxi = 0, maxn = 0;
cin >> a >> b >> c >> d;
maxi = max(3 * a / 10, a - a / 250 * c);
maxn = max(3 * b / 10, b - b / 250 * d);
if (maxi > maxn) {
cout << "Misha";
return 0;
} else if (maxi < maxn) {
cout << "Vasya";
return 0;
} else if (maxi == maxn) {
cout << "Tie";
return 0;
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[506][506], dp1[506][506];
long long int n, m;
vector<string> v(506, "mia_melona");
void mia_kalifa() {
for (long long int i = 1; i <= n; i++) {
for (long long int j = 2; j <= m; j++) {
if (v[i][j] == '.') {
if (v[i][j - 1] == '.') {
dp[i][j] = dp[i][j - 1] + 1;
} else {
dp[i][j] = dp[i][j - 1];
}
} else {
dp[i][j] = dp[i][j - 1];
}
}
}
}
void angela_white() {
for (long long int i = 1; i <= m; i++) {
for (long long int j = 2; j <= n; j++) {
if (v[j][i] == '.') {
if (v[j - 1][i] == '.') {
dp1[j][i] = dp1[j - 1][i] + 1;
} else {
dp1[j][i] = dp1[j - 1][i];
}
} else {
dp1[j][i] = dp1[j - 1][i];
}
}
}
}
void solve() {
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
cin >> v[i];
v[i] = '&' + v[i];
}
mia_kalifa();
angela_white();
long long int q;
cin >> q;
while (q--) {
long long int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
long long int ans = 0;
for (long long int i = r1; i <= r2; i++) {
ans = ans + (dp[i][c2] - dp[i][c1]);
}
for (long long int i = c1; i <= c2; i++) {
ans = ans + (dp1[r2][i] - dp1[r1][i]);
}
cout << ans;
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{ solve(); }
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 17;
int q;
bool check(string s, string t) {
int a[26] = {};
for (auto i : s) a[i - 'a']++;
for (auto i : t) a[i - 'a']--;
bool flag = false;
for (int i = 0; i < 26; i++)
if (a[i] != 0) flag = true;
return flag;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> q;
while (q--) {
int n, ans = 0, dp[MAXN][MAXN][2] = {};
cin >> n;
string s, t;
cin >> s >> t;
if (check(s, t)) {
cout << -1 << endl;
continue;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (s[i - 1] == t[j - 1]) {
dp[i][j][1] = max(dp[i - 1][j][1], dp[i - 1][j - 1][1] + 1);
dp[i][j][0] = max(dp[i][j - 1][0], dp[i][j][1]);
} else {
dp[i][j][1] = dp[i - 1][j][1];
dp[i][j][0] = max(dp[i][j][1], dp[i][j - 1][0]);
}
}
cout << n - dp[n][n][0] << endl;
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
int i, x, y, l = 1, r = n;
for (i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
if (x > y) swap(x, y);
l = max(l, x);
r = min(r, y);
}
cout << max(0, r - l);
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1000
const short N = 505;
short tc, cs = 1;
short n, x, arr[N], dp[N][N][N];
short vis[N][N][N];
short fun(short pos, short prevmx, short curx) {
if (pos > n) return 0;
short &ret = dp[pos][prevmx][curx];
if (vis[pos][prevmx][curx] == cs) return ret;
vis[pos][prevmx][curx] = 1;
ret = INF;
if (arr[pos] >= prevmx) {
if (arr[pos] > curx) {
if (curx >= prevmx) {
short v = fun(pos + 1, curx, arr[pos]) + 1;
if (v <= ret) ret = v;
}
short v = fun(pos + 1, arr[pos], curx);
if (v <= ret) ret = v;
} else {
short v = fun(pos + 1, arr[pos], curx);
if (v <= ret) ret = v;
}
}
return ret;
}
void test_cases() {
cin >> n >> x;
for (int i = 1; i <= n; ++i) cin >> arr[i];
short ans = fun(1, 0, x);
if (ans >= INF) cout << "-1" << '\n';
else cout << ans << '\n';
cs++;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> tc;
while (tc--) {
test_cases();
}
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6005;
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int n, x[N], y[N];
int f[N][4][4][4];
long long ans[2];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
int tmp = gcd(abs(x[i] - x[j]), abs(y[i] - y[j])) & 3;
f[i][tmp][x[j] & 3][y[j] & 3]++;
f[j][tmp][x[i] & 3][y[i] & 3]++;
}
for (int i = 1; i <= n; i++)
for (int p = 0; p < 4; p++)
for (int q = 0; q < 4; q++)
for (int xa = 0; xa < 4; xa++)
for (int ya = 0; ya < 4; ya++)
for (int xb = 0; xb < 4; xb++)
for (int yb = 0; yb < 4; yb++) {
int tmp = gcd(abs(xa - xb), abs(ya - yb));
if (tmp & 1) continue;
tmp = (tmp + p + q) >> 1;
int s = xa * yb - xb * ya + xb * y[i] - x[i] * yb + x[i] * ya -
xa * y[i];
if (!(((s >> 1) ^ tmp) & 1))
ans[p & 1] +=
1ll * f[i][p][xa][ya] *
(f[i][q][xb][yb] - (p == q && xa == xb && ya == yb));
}
cout << ans[0] / 6 + ans[1] / 2 << endl;
}
| 25
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, M = 1010;
long double dp[N * M], ps[N * M], l_ps[N * M], l_dp[N * M];
int r[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, sum = 0;
cin >> n >> m;
if (m == 1) {
cout << 1 << '\n';
return 0;
}
for (int i = 1; i <= n; i++) {
cin >> r[i];
sum += r[i];
}
l_dp[0] = 1;
for (int i = 0; i < N * M; i++) {
l_ps[i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int x = 1; x <= n * m; x++) {
if (x > m)
dp[x] = l_ps[x - 1] - l_ps[x - m - 1];
else
dp[x] = l_ps[x - 1];
if (x >= r[i]) dp[x] -= l_dp[x - r[i]];
dp[x] = dp[x] / (long double)(m - 1);
ps[x] = ps[x - 1] + dp[x];
}
for (int x = 0; x <= n * m; x++) {
l_dp[x] = dp[x];
l_ps[x] = ps[x];
}
}
long double ans = 0;
for (int i = 1; i < sum; i++) ans += dp[i];
ans *= (long double)(m - 1);
ans += (long double)1;
cout << fixed << setprecision(15) << ans << '\n';
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 18);
long long n, r, all, c[N];
void solve() {
cin >> n >> r;
for (int i = 0; i < (1 << n); ++i) {
cin >> c[i];
all += c[i];
}
cout << setprecision(6) << fixed << all / (long double)(1 << n) << "\n";
for (int i = 0; i < r; ++i) {
long long z, g;
cin >> z >> g;
all += g - c[z];
c[z] = g;
cout << setprecision(6) << fixed << all / (long double)(1 << n) << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
const int nn = 1 << 15;
int root[nn];
int d[nn];
int a[nn];
char s[nn];
int n, m;
int one, t;
int getRoot(int u) {
while (root[u] >= 0) u = root[u];
return u;
}
void Union(int u, int v) {
u = getRoot(u);
v = getRoot(v);
if (u == v) return;
t++;
if (v >= m) {
root[v] = u;
d[u] += d[v];
} else {
if (d[v] > d[u]) swap(u, v);
root[v] = u;
d[u] += d[v];
}
}
void grid() {
int I = 0;
for (int i = 0; s[i]; i++) {
int x = s[i];
if (s[i] >= '0' && s[i] <= '9')
x -= 48;
else
x -= 55;
for (int j = 3; j >= 0; j--) {
a[I] = (x >> j) & 1;
d[I] = a[I];
one += a[I];
root[I] = -1;
I++;
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
grid();
for (int j = 0; j < m; j++) {
if (a[j] == 0) continue;
if (j > 0 && a[j - 1]) {
Union(j, j - 1);
}
if (i > 0 && a[j + m] == 1) {
Union(j, j + m);
}
}
for (int j = 0; j < m; j++) {
a[j + m] = a[j];
a[j] = 0;
if (root[j] >= 0)
root[j + m] = root[j] + m;
else
root[j + m] = -1;
d[j + m] = d[j];
}
}
cout << one - t;
}
| 17
|
#include <bits/stdc++.h>
using int64 = long long;
using uchar = unsigned char;
constexpr int mxdg(65536);
constexpr int p(998244353);
constexpr int proot(3);
inline int io() {
static int _;
return scanf("%d", &_), _;
}
namespace math_template {
using Z = int;
using mZ = long long;
template <class _Tp>
inline void swap(_Tp& x, _Tp& y) {
_Tp z = x;
x = y;
y = z;
}
template <class _Tp>
inline Z fpow(_Tp v, int n) {
Z pw = 1;
for (; n; n >>= 1, v = (mZ)v * v % p)
if (n & 1) pw = (mZ)pw * v % p;
return pw;
}
template <class x_tp, class y_tp>
inline void inc(x_tp& x, const y_tp& y) {
(p - y <= x) ? (x += y - p) : (x += y);
}
template <class x_tp, class y_tp>
inline void dec(x_tp& x, const y_tp& y) {
x -= y;
(x < 0) && (x += p);
}
template <class x_tp, class y_tp>
inline x_tp pls(const x_tp& x, const y_tp& y) {
return (x < p - y) ? (x + y) : (x - p + y);
}
template <class x_tp, class y_tp>
inline x_tp sub(const x_tp& x, const y_tp& y) {
return (x < y) ? (x - y + p) : (x - y);
}
template <class _Tp>
inline _Tp gcd(const _Tp& x, const _Tp& y) {
return y ? gcd(y, x % y) : x;
}
template <class _Tp>
inline _Tp lcm(const _Tp& x, const _Tp& y) {
return x / gcd(x, y) * y;
}
template <class _Tp, class x_tp>
inline void exgcd(const _Tp& x, const _Tp& y, x_tp& a, x_tp& b) {
if (y)
exgcd(y, x % y, b, a), b -= x / y * a;
else
a = 1, b = 0;
}
inline Z inv(const Z& v, const Z& mp) {
Z x, y;
exgcd(v, mp, x, y);
return x < 0 ? x + mp : x;
}
template <class _Tp>
inline Z div2(const _Tp& v) {
return (v & 1) ? (v + p) >> 1 : (v >> 1);
}
template <class x_tp, class y_tp>
inline x_tp Min(const x_tp& x, const y_tp& y) {
return x < y ? x : y;
}
template <class x_tp, class y_tp>
inline x_tp Max(const x_tp& x, const y_tp& y) {
return x > y ? x : y;
}
template <class x_tp, class y_tp>
inline void chkMin(x_tp& x, const y_tp& y) {
(x > y) && (x = y);
}
template <class x_tp, class y_tp>
inline void chkMax(x_tp& x, const y_tp& y) {
(x < y) && (x = y);
}
template <class x_tp, class y_tp>
inline bool bchkMin(x_tp& x, const y_tp& y) {
return (x > y) && (x = y, 1);
}
template <class x_tp, class y_tp>
inline bool bchkMax(x_tp& x, const y_tp& y) {
return (x < y) && (x = y, 1);
}
} // namespace math_template
namespace Hashmap {
using namespace math_template;
template <class key_tp, class val_tp>
struct link_t {
key_tp key;
val_tp val;
link_t<key_tp, val_tp>* las;
link_t() : key(key_tp(0)), val(val_tp(0)), las(nullptr) {}
inline link_t* init(const key_tp& _key, const val_tp& _val,
link_t<key_tp, val_tp>* const& ls) {
return key = _key, val = _val, las = ls, this;
}
};
link_t<Z, Z> lnk_pool[100007 * 10];
template <class key_tp, class val_tp>
struct hashmap {
static constexpr int hashp = 100007;
using link = link_t<key_tp, val_tp>;
link *lnk[hashp], *lnk_alc;
hashmap() : lnk_alc(lnk_pool - 1) {}
inline val_tp& operator[](const key_tp& key) {
const val_tp hash_key = key % hashp;
for (link* o = lnk[hash_key]; o; o = o->las)
if (o->key == key) return o->val;
lnk[hash_key] = (++lnk_alc)->init(key, 0, lnk[hash_key]);
return lnk[hash_key]->val;
}
inline bool count(const key_tp& key) {
const val_tp hash_key = key % hashp;
for (link* o = lnk[hash_key]; o; o = o->las)
if (o->key == key) return true;
return false;
}
inline void clear() {
lnk_alc = lnk_pool - 1;
memset(lnk, 0, sizeof lnk);
}
};
} // namespace Hashmap
namespace poly {
using namespace math_template;
using namespace Hashmap;
using poly_t = Z[mxdg];
using poly = Z* const;
inline int calcpw2(const int& n) {
int pw2 = 1;
for (; pw2 < n; pw2 += pw2)
;
return pw2;
}
poly_t wn, iwn;
Z inv[mxdg + 1];
constexpr int rt_blk(31596);
constexpr int invpw_blk(393213064);
Hashmap::hashmap<Z, Z> lg;
inline void polyinit() {
const Z wnv = fpow(proot, (p - 1) / mxdg);
const Z iwnv = fpow(wnv, p - 2);
wn[0] = iwn[0] = inv[0] = inv[1] = 1;
Z w = 1, iw = 1, b = 1;
for (int i = 1; i != mxdg; ++i) {
w = (mZ)w * wnv % p;
wn[i] = w;
iw = (mZ)iw * iwnv % p;
iwn[i] = iw;
}
for (int i = 2; i <= mxdg; ++i) inv[i] = (mZ)inv[p % i] * (p - p / i) % p;
for (int t = 0; t < rt_blk; ++t, b = (mZ)b * proot % p) lg[b] = t;
}
inline int root(const Z& v, const int& k) {
if (k == 1 || v < 2) return v;
Z pw = v;
for (int t = 0; t < p; t += rt_blk, pw = (mZ)pw * invpw_blk % p)
if (lg.count(pw))
return fpow(proot,
(mZ)(t + lg[pw]) * math_template::inv(k, p - 1) % (p - 1));
return -1;
}
void DFT(poly& A, const int& n) {
for (int i = 0, j = 0; i != n; ++i) {
if (i < j) swap(A[i], A[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
Z* const td = A + n;
for (int l = 1, tp = mxdg >> 1; l != n; l += l, tp >>= 1)
for (Z *i = A, *w, z; i < td; i += l + l)
for (int j = (w = wn, 0); j != l; ++j, w += tp)
z = (mZ)i[j + l] * *w % p, i[j + l] = sub(i[j], z), inc(i[j], z);
}
void IDFT(poly& A, const int& n) {
for (int i = 0, j = 0; i != n; ++i) {
if (i < j) swap(A[i], A[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
Z* const td = A + n;
for (int l = 1, tp = mxdg >> 1; l != n; l += l, tp >>= 1)
for (Z *i = A, *w, z; i < td; i += l + l)
for (int j = (w = iwn, 0); j != l; ++j, w += tp)
z = (mZ)i[j + l] * *w % p, i[j + l] = sub(i[j], z), inc(i[j], z);
const Z invn = fpow(n, p - 2);
for (Z* i = A; i != td; ++i) *i = (mZ)*i * invn % p;
}
inline void cp(const Z* const& sl, const Z* const& sr, Z* const& dl,
Z* const& dr) {
std::copy(sl, sr, dl);
if (sr - sl < dr - dl) std::fill(dl + (sr - sl), dr, 0);
}
void polyder(const poly& f, poly& df, const int& n) {
for (int i = 1; i != n; ++i) df[i - 1] = (mZ)f[i] * i % p;
df[n - 1] = 0;
}
void polyint(const poly& f, poly& intf, const int& n) {
for (int i = n - 1; i; --i) intf[i] = (mZ)f[i - 1] * inv[i] % p;
intf[0] = 0;
}
void polyinv(const poly& h, poly& f, const int& n) {
static poly_t inv_t;
std::fill(f, f + n + n, 0);
f[0] = fpow(h[0], p - 2);
for (int t = 1; (1 << t) <= n; ++t) {
const int deg1 = 1 << t, deg2 = deg1 << 1;
cp(h, h + deg1, inv_t, inv_t + deg2);
DFT(f, deg2);
DFT(inv_t, deg2);
for (int i = 0; i != deg2; ++i)
f[i] = (mZ)f[i] * sub(2ll, (mZ)inv_t[i] * f[i] % p) % p;
IDFT(f, deg2);
std::fill(f + deg1, f + deg2, 0);
}
}
void polyln(const poly& h, poly& f, const int& n) {
static poly_t ln_t;
assert(h[0] == 1);
const int n2 = n << 1;
polyder(h, f, n);
std::fill(f + n, f + n2, 0);
polyinv(h, ln_t, n);
DFT(f, n2);
DFT(ln_t, n2);
for (int i = 0; i != n2; ++i) f[i] = (mZ)f[i] * ln_t[i] % p;
IDFT(f, n2);
polyint(f, f, n);
std::fill(f + n, f + n2, 0);
}
void polyexp(const poly& h, poly& f, const int& n) {
static poly_t exp_t;
assert(h[0] == 0);
std::fill(f, f + n + n, 0);
f[0] = 1;
for (int t = 1; (1 << t) <= n; ++t) {
const int deg1 = 1 << t, deg2 = deg1 << 1;
polyln(f, exp_t, deg1);
exp_t[0] = sub(h[0] + 1, exp_t[0]);
for (int i = 1; i != deg1; ++i) exp_t[i] = sub(h[i], exp_t[i]);
std::fill(exp_t + deg1, exp_t + deg2, 0);
DFT(f, deg2);
DFT(exp_t, deg2);
for (int i = 0; i != deg2; ++i) f[i] = (mZ)f[i] * exp_t[i] % p;
IDFT(f, deg2);
std::fill(f + deg1, f + deg2, 0);
}
}
void polydiv(const poly& f, const int& n, const poly& g, const int& m, poly& Q,
poly& R) {
static poly_t div_t;
const int res = n - m + 1;
const int deg1 = calcpw2(res + res);
std::reverse_copy(g, g + m, Q);
if (m < deg1) std::fill(Q + m, Q + deg1, 0);
polyinv(Q, div_t, res);
std::reverse_copy(f + m - 1, f + n, Q);
std::fill(Q + res, Q + deg1, 0);
DFT(Q, deg1);
DFT(div_t, deg1);
for (int i = 0; i != deg1; ++i) Q[i] = (mZ)Q[i] * div_t[i] % p;
IDFT(Q, deg1);
std::reverse(Q, Q + res);
std::fill(Q + res, Q + deg1, 0);
const int deg2 = calcpw2(n);
cp(Q, Q + res, R, R + deg2);
cp(g, g + m, div_t, div_t + deg2);
DFT(R, deg2);
DFT(div_t, deg2);
for (int i = 0; i != deg2; ++i) R[i] = (mZ)R[i] * div_t[i] % p;
IDFT(R, deg2);
for (int i = 0; i != m; ++i) R[i] = sub(f[i], R[i]);
std::fill(R + m - 1, R + deg2, 0);
}
void polymod(const poly& f, const int& n, const poly& g, const int& m,
poly& R) {
static poly_t mod_t;
const int res = n - m + 1;
const int deg1 = calcpw2(res + res);
std::reverse_copy(g, g + m, R);
if (m < deg1) std::fill(R + m, R + deg1, 0);
polyinv(R, mod_t, res);
std::reverse_copy(f + m - 1, f + n, R);
std::fill(R + res, R + deg1, 0);
DFT(R, deg1);
DFT(mod_t, deg1);
for (int i = 0; i != deg1; ++i) R[i] = (mZ)R[i] * mod_t[i] % p;
IDFT(R, deg1);
std::reverse(R, R + res);
std::fill(R + res, R + deg1, 0);
const int deg2 = calcpw2(n);
cp(g, g + m, mod_t, mod_t + deg2);
DFT(R, deg2);
DFT(mod_t, deg2);
for (int i = 0; i != deg2; ++i) R[i] = (mZ)R[i] * mod_t[i] % p;
IDFT(R, deg2);
for (int i = 0; i != m; ++i) R[i] = sub(f[i], R[i]);
std::fill(R + m - 1, R + deg2, 0);
}
void polysqrt(const poly& h, poly& f, const int& n) {
static poly_t sqrt_t, inv_t;
std::fill(f, f + n + n, 0);
f[0] = root(h[0], 2);
for (int t = 1; (1 << t) <= n; ++t) {
const int deg1 = 1 << t, deg2 = deg1 << 1;
polyinv(f, inv_t, deg1);
cp(h, h + deg1, sqrt_t, sqrt_t + deg2);
DFT(sqrt_t, deg2);
DFT(inv_t, deg2);
for (int i = 0; i != deg2; ++i) sqrt_t[i] = (mZ)inv_t[i] * sqrt_t[i] % p;
IDFT(sqrt_t, deg2);
for (int i = deg1 >> 1; i != deg1; ++i) f[i] = div2(sqrt_t[i]);
std::fill(f + deg1, f + deg2, 0);
}
}
void polycbrt(const poly& h, poly& f, const int& n) {
static constexpr int inv3(332748118);
static poly_t cbrt_t, inv_t;
std::fill(f, f + n + n, 0);
f[0] = root(h[0], 3);
for (int t = 1; (1 << t) <= n; ++t) {
const int deg1 = 1 << t, deg2 = deg1 << 1;
cp(f, f + (deg1 >> 1), cbrt_t, cbrt_t + deg2);
DFT(cbrt_t, deg1);
Z* const td = cbrt_t + deg1;
for (Z* i = cbrt_t; i != td; ++i) *i = (mZ)*i * *i % p;
IDFT(cbrt_t, deg1);
polyinv(cbrt_t, inv_t, deg1);
cp(h, h + deg1, cbrt_t, cbrt_t + deg2);
DFT(cbrt_t, deg2);
DFT(inv_t, deg2);
for (int i = 0; i != deg2; ++i) cbrt_t[i] = (mZ)cbrt_t[i] * inv_t[i] % p;
IDFT(cbrt_t, deg2);
for (int i = deg1 >> 1; i != deg1; ++i)
f[i] = (mZ)(f[i] + f[i] + cbrt_t[i]) * inv3 % p;
}
}
void polypow(const poly& h, poly& f, const int& k, const int& n) {
static poly_t pow_t;
if (h[0] == 1) {
polyln(h, pow_t, n);
Z* const td = pow_t;
for (Z* i = pow_t; i != td; ++i) *i = (mZ)*i * k % p;
polyexp(pow_t, f, n);
} else {
int lw = 0;
for (; !h[lw]; ++lw)
;
if (n <= lw * k) return std::fill(f, f + n, 0);
const int low = lw;
const Z ilowc = fpow(h[low], p - 2);
for (int i = 0; i != n - low; ++i) pow_t[i] = (mZ)h[i + low] * ilowc % p;
std::fill(pow_t + n - low, pow_t + n, 0);
polyln(pow_t, f, n);
Z* const td = f + n;
for (Z* i = f; i != td; ++i) *i = (mZ)*i * k % p;
polyexp(f, pow_t, n);
const int pwlow = low * k;
const Z pwlowc = fpow(h[low], k);
for (int i = 0; i != n - pwlow; ++i)
f[i + pwlow] = (mZ)pow_t[i] * pwlowc % p;
std::fill(f, f + pwlow, 0);
}
}
void polyroot(const poly& h, poly& f, const int& k, const int& n) {
static poly_t root_t;
const int invk(fpow(k, p - 2));
if (h[0] == 1) {
polyln(h, root_t, n);
Z* const td = root_t + n;
for (Z* i = root_t; i != td; ++i) *i = (mZ)*i * invk % p;
polyexp(root_t, f, n);
} else {
int lw = 0;
for (; !h[lw]; ++lw)
;
assert(lw % k == 0);
const int low = lw;
const Z ilowc = fpow(h[low], p - 2);
for (int i = 0; i != n - low; ++i) root_t[i] = (mZ)h[i + low] * ilowc % p;
std::fill(root_t + n - low, root_t + n, 0);
polyln(root_t, f, n);
Z* const td = f + n;
for (Z* i = f; i != td; ++i) *i = (mZ)*i * invk % p;
polyexp(f, root_t, n);
const int pwlow = low / k;
const Z pwlowc = root(h[low], k);
for (int i = 0; i != n - pwlow; ++i)
f[i + pwlow] = (mZ)root_t[i] * pwlowc % p;
std::fill(f, f + pwlow, 0);
}
}
} // namespace poly
using namespace poly;
poly_t f, g, rt, invrt;
int main() {
polyinit();
const int n = io() + 1, k = io() + 1, deg = 32768, deg2 = deg + deg;
f[0] = 1;
f[1] = 6;
f[2] = 1;
polysqrt(f, rt, deg);
polyinv(rt, invrt, deg);
g[0] = div2(rt[0] + 1);
g[1] = div2(rt[1] + 1);
for (int i = 2; i != deg; ++i) g[i] = div2(rt[i]);
polyln(g, f, deg);
for (int i = 0; i != deg; ++i) f[i] = (int64)f[i] * n % p;
polyexp(f, g, deg);
DFT(g, deg2);
DFT(invrt, deg2);
for (int i = 0; i != deg2; ++i) g[i] = (int64)g[i] * invrt[i] % p;
IDFT(g, deg2);
const int lw = Min(n, k);
for (int i = 1; i != lw; ++i) printf("%d ", g[i]);
for (int i = lw; i != k; ++i) putchar('0'), putchar(' ');
return 0;
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, numofdig;
cin >> n >> numofdig;
long long int counter = 0, arr = 0;
for (long long int i = 0; i < n; i++) {
cin >> arr;
counter += arr + 1;
}
if (counter - 1 == numofdig)
cout << "YES";
else
cout << "NO";
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10, M = 2e5 + 100, MOD = 1e9 + 7, MAXN = 1e5 + 10;
const long long inf = 4e18 + 10;
int dp[N][N][30];
vector<pair<int, int> > v[N];
int go(int i, int j, int k) {
if (dp[i][j][k] != 0) return dp[i][j][k];
for (int x = 0; x < (int)v[i].size(); x++) {
if (v[i][x].second >= k) {
if (go(j, v[i][x].first, v[i][x].second) == 2) {
dp[i][j][k] = 1;
return 1;
}
}
}
dp[i][j][k] = 2;
return 2;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y, z;
char c;
cin >> x >> y >> c;
z = int(c) - 'a';
v[x].push_back(make_pair(y, z));
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (go(i, j, 0) == 1)
cout << 'A';
else
cout << 'B';
}
cout << endl;
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &first, T second) {
first < second ? first = second : T();
}
template <typename T>
void chkmin(T &first, T second) {
first > second ? first = second : T();
}
template <typename T>
void readint(T &first) {
first = 0;
int f = 1;
char c;
for (c = getchar(); !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) first = first * 10 + (c - '0');
first *= f;
}
const int MOD = 998244353;
inline int dmy(int first) { return first >= MOD ? first - MOD : first; }
inline void inc(int &first, int second) { first = dmy(first + second); }
int qmi(int first, int second) {
int ans = 1;
for (; second; second >>= 1, first = 1ll * first * first % MOD)
if (second & 1) ans = 1ll * ans * first % MOD;
return ans;
}
const int MAXN = 500005, MAXK = 19;
int n, _u[MAXN], _v[MAXN];
vector<pair<int, int> > G[MAXN];
int dfn[MAXN], size[MAXN], d0[MAXN], d1[MAXN], col[MAXN], ded[MAXN], dfn_cnt;
void dfs(int u, int pa, int *dep) {
size[u] = 1;
dfn[u] = ++dfn_cnt;
ded[dfn_cnt] = u;
for (auto p : G[u]) {
int v = p.first, c = p.second;
if (v == pa) continue;
dep[v] = dep[u] + 1;
col[v] = col[u] ^ c;
dfs(v, u, dep);
size[u] += size[v];
}
}
int co[MAXN << 2], mu[MAXN << 2][2][2], tag[MAXN << 2];
void maintain(int id) {
swap(mu[id][0][0], mu[id][1][0]);
swap(mu[id][0][1], mu[id][1][1]);
co[id] ^= 1;
tag[id] ^= 1;
}
void update(int id) {
for (int t = 0; t <= 1; ++t)
mu[id][0][t] = max(mu[id << 1][0][t], mu[id << 1 | 1][0][t]),
mu[id][1][t] = max(mu[id << 1][1][t], mu[id << 1 | 1][1][t]);
}
void pushdown(int id) {
if (!tag[id]) return;
maintain(id << 1), maintain(id << 1 | 1);
tag[id] = 0;
}
void build(int id, int l, int r) {
tag[id] = 0;
if (l == r) {
co[id] = col[ded[l]];
mu[id][co[id]][0] = d0[ded[l]];
mu[id][co[id]][1] = d1[ded[l]];
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
update(id);
}
void modify(int id, int l, int r, int ql, int qr) {
if (l == ql && r == qr) {
maintain(id);
return;
}
pushdown(id);
int mid = (l + r) >> 1;
if (qr <= mid)
modify(id << 1, l, mid, ql, qr);
else if (ql > mid)
modify(id << 1 | 1, mid + 1, r, ql, qr);
else
modify(id << 1, l, mid, ql, mid),
modify(id << 1 | 1, mid + 1, r, mid + 1, qr);
update(id);
}
int query(int id, int l, int r, int ql, int qr, int t, int s) {
if (l == ql && r == qr) return mu[id][t][s];
pushdown(id);
int mid = (l + r) >> 1;
if (qr <= mid) return query(id << 1, l, mid, ql, qr, t, s);
if (ql > mid) return query(id << 1 | 1, mid + 1, r, ql, qr, t, s);
return max(query(id << 1, l, mid, ql, mid, t, s),
query(id << 1 | 1, mid + 1, r, mid + 1, qr, t, s));
}
int qcol(int id, int l, int r, int first) {
if (l == r) return co[id];
pushdown(id);
int mid = (l + r) >> 1;
if (first <= mid) return qcol(id << 1, l, mid, first);
return qcol(id << 1 | 1, mid + 1, r, first);
}
int main() {
int Q;
readint(n);
for (int i = 1; i < n; ++i) {
int c;
readint(_u[i]), readint(_v[i]), readint(c);
G[_u[i]].push_back(make_pair(_v[i], c));
G[_v[i]].push_back(make_pair(_u[i], c));
}
dfs(1, -1, d1);
int u = 1;
for (int i = 2; i <= n; ++i)
if (d1[i] > d1[u]) u = i;
dfn_cnt = 0;
dfs(u, -1, d0);
int v = 1;
for (int i = 2; i <= n; ++i)
if (d0[i] > d0[v]) v = i;
d1[v] = 0;
dfn_cnt = 0;
dfs(v, -1, d1);
d1[0] = d0[0] = -1;
for (int i = 1; i < n; ++i)
if (d1[_u[i]] > d1[_v[i]]) swap(_u[i], _v[i]);
memset(mu, -1, sizeof(mu));
build(1, 1, n);
readint(Q);
while (Q--) {
int first;
readint(first);
first = _v[first];
modify(1, 1, n, dfn[first], dfn[first] + size[first] - 1);
int cu = qcol(1, 1, n, dfn[u]), cv = qcol(1, 1, n, dfn[v]);
if (cu == cv)
printf("%d\n", d0[v]);
else
printf("%d\n", max(mu[1][cu][0], mu[1][cv][1]));
}
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 1000;
vector<int> adj[MAXN], com[MAXN];
int nxt[MAXN];
bool mark[MAXN];
int n, m;
int fnxt(int x) { return nxt[x] == x ? x : nxt[x] = fnxt(nxt[x]); }
void dfs(int v, int cnt) {
mark[v] = true;
nxt[v] = v + 1;
com[cnt].push_back(v);
for (int i = fnxt(1), j = 0; i <= n; i = fnxt(i + 1)) {
while (j < adj[v].size() and adj[v][j] < i) j++;
if (j == adj[v].size() or i != adj[v][j]) dfs(i, cnt);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n + 1; i++) nxt[i] = i;
for (int i = 0, a, b; i < m; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 0; i <= n; i++) sort(adj[i].begin(), adj[i].end());
int cnt = 0;
for (int i = fnxt(1); i <= n; i = fnxt(i))
if (!mark[i]) dfs(i, cnt++);
cout << cnt << '\n';
for (int i = 0; i < cnt; i++) {
cout << com[i].size() << " ";
for (auto j : com[i]) cout << j << " ";
cout << '\n';
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
const int INF = 1e9 + 10;
const double Pi = acos(-1.0);
const double EPS = 1e-10;
struct Point {
double x, y;
friend Point operator-(Point A, Point B) { return {A.x - B.x, A.y - B.y}; }
friend double operator*(Point A, Point B) { return A.x * B.y - A.y * B.x; }
void debug() { printf("x=%.2f y=%.2f\n", x, y); }
friend bool operator==(Point A, Point B) {
return fabs(A.x - B.x) < EPS && fabs(A.y - B.y) < EPS;
}
};
Point A, B, C, D;
Point At, Bt, Ct, Dt;
double w, h;
double a;
Point Inter(Point A, Point B, Point C, Point D) {
double area1 = fabs((B - A) * (C - A));
double area2 = fabs((B - A) * (D - A));
double x = (area1 * D.x + area2 * C.x) / (area1 + area2);
double y = (area1 * D.y + area2 * C.y) / (area1 + area2);
return {x, y};
}
double dist(Point A, Point B) {
double tx = A.x - B.x, ty = A.y - B.y;
return sqrt(tx * tx + ty * ty);
}
Point rot(Point A, double a) {
double p = sqrt(A.x * A.x + A.y * A.y);
double th = atan(A.y / A.x);
if (A.x < -EPS) th += Pi;
th += a;
return {p * cos(th), p * sin(th)};
}
int judge() {
if (Dt * B > EPS) return 1;
return 0;
}
void work() {
Point X = Inter(A, B, At, Bt);
Point Y = Inter(A, B, Ct, Dt);
double res = (h * 2) * dist(X, Y);
printf("%.9f\n", res + EPS);
}
void solve() {
a = Pi * 2 * a / 360;
w /= 2;
h /= 2;
A = {-w, h};
B = {w, h};
C = {-w, -h};
D = {w, -h};
At = rot(A, a);
Bt = rot(B, a);
Ct = rot(C, a);
Dt = rot(D, a);
int jud = judge();
if (jud == 0) {
work();
return;
}
Point X, Y;
double cut = 0;
if (A == Bt && B == Dt || fabs(a) < EPS)
;
else {
X = Inter(A, C, At, Bt);
Y = Inter(A, B, At, Bt);
cut += fabs(A.y - X.y) * fabs(A.x - Y.x) / 2;
}
if (B == Dt && A == Bt || fabs(a) < EPS)
;
else {
X = Inter(Bt, Dt, A, B);
Y = Inter(B, D, Bt, Dt);
cut += dist(B, X) * dist(B, Y) / 2;
}
double res = (w * 2) * (h * 2);
res -= cut * 2;
printf("%.9f\n", res + EPS);
}
int main() {
int ta = 0;
while (cin >> w >> h >> ta) {
ta %= 180;
if (ta > 90) ta = 180 - ta;
if (w < h) swap(w, h);
a = ta;
solve();
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
struct seg {
long long l, r, id;
bool operator<(const seg &t) const {
if (r != t.r) return r < t.r;
return l < t.l;
}
};
struct my_pair {
long long first;
int second;
bool operator==(const my_pair &t) const { return (first == t.first); }
bool operator<(const my_pair &t) const { return first < t.first; }
};
int main() {
int n, m;
scanf("%d %d", &n, &m);
n--;
vector<seg> segs;
long long last_l, last_r;
scanf("%lld %lld", &last_l, &last_r);
vector<int> answer(n);
for (int i = 0; i < n; ++i) {
long long l, r;
scanf("%lld %lld", &l, &r);
seg add = {l - last_r, r - last_l, i};
segs.push_back(add);
last_l = l, last_r = r;
}
sort(segs.begin(), segs.end());
multiset<my_pair> bridges;
multiset<my_pair>::iterator it;
for (int i = 0; i < m; ++i) {
my_pair add;
scanf("%lld", &add.first);
add.second = i + 1;
bridges.insert(add);
}
for (int i = 0; i < n; ++i) {
my_pair check = {segs[i].l, 0};
it = bridges.lower_bound(check);
if (it == bridges.end() || (*it).first > segs[i].r) {
printf("No\n");
return 0;
}
answer[segs[i].id] = (*it).second;
bridges.erase(it);
}
printf("Yes\n");
for (int i = 0; i < answer.size(); ++i)
printf("%d%c", answer[i], " \n"[i == answer.size() - 1]);
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
reverse(a.begin(), a.end());
for (int c : a) {
cout << c << " ";
}
cout << "\n";
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long max = 0;
long long x;
cin >> x;
if (x != 0) {
cout << 1;
return 0;
}
if (n == 1) {
cout << -1;
return 0;
}
for (int i = 1; i < n; i++) {
long long x;
cin >> x;
if (x > max) {
if (x - max > 1) {
cout << i + 1;
return 0;
}
max = x;
}
}
cout << -1;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2000 + 5;
const int MAX_E = 100 * 1000 + 5;
vector<pair<long long, long long> > adj[MAX_N], A, B;
long long N, E, K, PA, push_back, P[MAX_N], Sum[MAX_N][MAX_N];
int SZ[MAX_N][MAX_N], SZA, SZB;
vector<long long> DA, DB;
long long ALLSUM, Ans;
pair<long long, long long> QA[MAX_N][2], QB[MAX_N][2];
bool mrk[MAX_N];
long long D[MAX_N];
void Dijstkra(int s, vector<pair<long long, long long> > &V,
vector<long long> &H) {
D[s] = 0;
for (int tmp = 0; tmp < N; tmp++) {
int mn = -1;
for (int i = 1; i <= N; i++)
if (!mrk[i] && (mn == -1 || D[mn] > D[i])) mn = i;
mrk[mn] = true;
V.push_back(pair<long long, long long>(D[mn], mn));
H.push_back(D[mn]);
for (int i = 0; i < (int)adj[mn].size(); i++) {
int v = adj[mn][i].first;
if (mrk[v]) continue;
D[v] = min(D[v], D[mn] + adj[mn][i].second);
}
}
}
void CLR() {
A.clear(), B.clear();
DA.clear(), DB.clear();
Ans = 0;
ALLSUM = 0;
for (int i = 0; i < MAX_N; i++) {
adj[i].clear();
P[i] = 0;
QA[i][0] = make_pair(0LL, 0LL);
QA[i][1] = make_pair(0LL, 0LL);
QB[i][0] = make_pair(0LL, 0LL);
QB[i][1] = make_pair(0LL, 0ll);
for (int j = 0; j < MAX_N; j++) Sum[i][j] = 0, SZ[i][j] = 0;
}
}
void FillSum() {
memset(mrk, 0, sizeof(mrk));
memset(D, 63, sizeof(D));
Dijstkra(PA, A, DA);
memset(mrk, 0, sizeof(mrk));
memset(D, 63, sizeof(D));
Dijstkra(push_back, B, DB);
sort(DA.begin(), DA.end());
DA.resize(unique(DA.begin(), DA.end()) - DA.begin());
sort(DB.begin(), DB.end());
DB.resize(unique(DB.begin(), DB.end()) - DB.begin());
SZA = (int)DA.size();
SZB = (int)DB.size();
memset(mrk, 0, sizeof(mrk));
long long AnsA = ALLSUM, P1 = 0, SizeA = N;
for (int i = 0; i < SZA; i++) {
while (P1 < (int)A.size() && A[P1].first < DA[i]) {
AnsA -= P[A[P1].second];
mrk[A[P1].second] = true;
SizeA--;
P1++;
}
long long P2 = 0, AnsB = AnsA, SizeB = SizeA;
for (int j = 0; j < SZB; j++) {
while (P2 < (int)B.size() && B[P2].first < DB[j]) {
if (!mrk[B[P2].second]) AnsB -= P[B[P2].second], SizeB--;
P2++;
}
Sum[i][j] = AnsB;
SZ[i][j] = SizeB;
}
}
}
int main() {
CLR();
scanf("%lld%lld", &N, &E);
scanf("%lld%lld", &PA, &push_back);
for (int i = 1; i <= N; i++) scanf("%lld", P + i), ALLSUM += P[i];
for (int i = 0; i < E; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
adj[u].push_back(pair<long long, long long>(v, w));
adj[v].push_back(pair<long long, long long>(u, w));
}
FillSum();
for (int i = SZA; i >= 0; i--)
for (int j = SZB; j >= 0; j--)
for (int k = 0; k < 2; k++) {
if (!SZ[i][j]) continue;
if (!k) {
long long TMP;
if (SZ[i][j] == QA[j][0].first)
TMP = QA[j][1].second;
else
TMP = QA[j][0].second;
long long DUMMY = TMP + Sum[i][j];
if (SZ[i][j] == QB[i][0].first)
QB[i][0].second = max(QB[i][0].second, -DUMMY);
else {
QB[i][0].second = max(QB[i][0].second, QB[i][1].second);
QB[i][1] = QB[i][0];
QB[i][0] = make_pair(SZ[i][j], -DUMMY);
QB[i][0].second = max(QB[i][0].second, QB[i][1].second);
}
if (!i && !j) Ans = DUMMY;
} else {
long long TMP;
if (SZ[i][j] == QB[i][0].first)
TMP = QB[i][1].second;
else
TMP = QB[i][0].second;
long long DUMMY = TMP + Sum[i][j];
if (SZ[i][j] == QA[j][0].first)
QA[j][0].second = max(QA[j][0].second, -DUMMY);
else {
QA[j][0].second = max(QA[j][0].second, QA[j][1].second);
QA[j][1] = QA[j][0];
QA[j][0] = make_pair(SZ[i][j], -DUMMY);
QA[j][0].second = max(QA[j][0].second, QA[j][1].second);
}
}
}
if (2 * Ans > ALLSUM)
cout << "Break a heart" << endl;
else if (2 * Ans == ALLSUM)
cout << "Flowers" << endl;
else
cout << "Cry" << endl;
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
int n, l[100105];
long long dp[100105][11], ans = 0;
int c[100105];
char s[100105];
int main() {
scanf("%s", s + 1);
n = (int)strlen(s + 1);
for (int i = 1; i <= n; i++) {
int k = s[i] - '0';
if (k) dp[i][k] = 1;
for (int j = 0; j < 11; j++)
if (dp[i - 1][j]) {
int nx = j * (j - 1) / 2 + 9;
if (k < j % 11) dp[i][(nx + k + 1) % 11] += dp[i - 1][j];
}
for (int j = 0; j < 11; j++) ans += dp[i][j];
}
cout << ans << endl;
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
vector<int> t(500500);
int main() {
int n, k;
scanf("%d %d", &n, &k);
int kk = k;
int cnt = 0;
for (int i = 0; i < int(n); i++) {
scanf("%d", &t[i + 1]);
if (t[i + 1] < 0) cnt++;
}
if (cnt > k)
printf("-1\n");
else {
k -= cnt;
int j = 1;
while (j <= n && t[j] >= 0) j++;
if (j > n)
printf("0\n");
else {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
int cnt = 0;
bool neg = true;
vector<pair<int, int> > v;
for (int i = j; i <= n; i++) {
if (neg) {
if (t[i] < 0)
cnt++;
else {
v.push_back(make_pair(cnt, -1));
neg = false;
cnt = 1;
}
} else {
if (t[i] >= 0)
cnt++;
else {
v.push_back(make_pair(cnt, 1));
neg = true;
cnt = 1;
}
}
}
if (neg)
v.push_back(make_pair(cnt, -1));
else
v.push_back(make_pair(cnt, 1));
int solution1 = ((int)(v).size()), solution2 = ((int)(v).size()), l = k;
for (int i = 0; i < ((int)(v).size()); i++)
if (v[i].second == 1) {
if (i != ((int)(v).size()) - 1)
pq.push(make_pair(v[i].first, 0));
else {
if (v[i].first <= l) {
l -= v[i].first;
solution2--;
}
}
}
while (!pq.empty()) {
if (pq.top().first <= k) {
k -= pq.top().first;
solution1 -= 2;
}
if (pq.top().first <= l) {
l -= pq.top().first;
solution2 -= 2;
}
pq.pop();
}
printf("%d\n", min(solution1, solution2));
}
}
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int k;
cin >> k;
int n[3];
cin >> n[0] >> n[1] >> n[2];
int t[3];
cin >> t[0] >> t[1] >> t[2];
int ans = 0;
int cn[3];
memcpy(cn, n, sizeof(n));
int N = k * (t[0] + t[1] + t[2]);
int sz = 3000;
int evs[sz][7];
memset(evs, 0, sizeof(evs));
evs[0][0] = k;
for (int i = 0; i <= N; ++i) {
int ii = (i % sz);
for (int j = 4; j < 7; ++j) {
cn[j - 4] += evs[ii][j];
evs[ii][j] = 0;
}
if (evs[ii][3]) {
ans = max(ans, i);
evs[ii][3] = 0;
}
for (int j = 0; j < 3; ++j) {
int cc = min(cn[j], evs[ii][j]);
int tt = i + t[j];
if (tt <= N) {
evs[tt % sz][j + 1] += cc;
evs[tt % sz][j + 4] += cc;
cn[j] -= cc;
evs[(ii + 1) % sz][j] += (evs[ii][j] - cc);
}
evs[ii][j] = 0;
}
}
cout << ans << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
void write(int x) {
if (x < 10) {
putchar(x + '0');
return;
}
write(x / 10);
putchar(x % 10 + '0');
return;
}
int maxt(int a, int b) { return a > b ? a : b; }
int mint(int a, int b) { return a < b ? a : b; }
int n, a[26], ans[2005 * 3], cnt;
char s[2005], t[2005];
int main() {
n = read();
for (int i = 1; i <= n; i++) s[i] = getchar(), a[s[i] - 'a']++;
s[n + 1] = getchar();
for (int i = 1; i <= n; i++) t[i] = getchar(), a[t[i] - 'a']--;
for (int i = 0; i < 26; i++)
if (a[i]) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
int lbc = 0;
for (int j = n; j >= 1; j--)
if (t[i] == s[j] && n - j + 1 >= i) {
lbc = j;
break;
}
if (n - lbc) ans[++cnt] = n - lbc;
ans[++cnt] = 1;
ans[++cnt] = n;
for (int j = 1; j <= (lbc >> 1); j++) {
int tmp = s[j];
s[j] = s[lbc - j];
s[lbc - j] = tmp;
}
for (int j = lbc; j < n; j++) s[j] = s[j + 1];
s[n] = t[i];
}
write(cnt), putchar('\n');
for (int i = 1; i <= cnt; i++) write(ans[i]), putchar(' ');
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using ld = long double;
using ii = pair<int, int>;
using vi = vector<int>;
using vii = vector<ii>;
const int N = 1e6 + 5;
lli a, b, c, d;
void testCase() {
cin >> a >> b >> c >> d;
cout << abs(a - c) * abs(b - d) + 1 << '\n';
}
int main() {
cin.tie(0)->sync_with_stdio(0), cout.tie(0);
int tc;
cin >> tc;
while (tc--) testCase();
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int minA = 105, maxA = 0, minB = 105;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
minA = min(minA, a);
maxA = max(maxA, a);
}
for (int i = 0; i < m; i++) {
int b;
cin >> b;
minB = min(minB, b);
}
maxA = max(maxA, 2 * minA);
if (minB <= maxA) {
cout << -1 << endl;
} else {
cout << maxA;
}
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long l, long long md) {
long long res = 1;
while (l) {
if (l & 1) res = res * a % md;
l /= 2;
a = a * a % md;
}
return res;
}
const long long Nmax = 1000005;
const long long INF = 1000000000;
const long long MOD = 1000000007;
long long a[Nmax], fr[Nmax];
long long do_calc(long long x, long long p, long long y) {
if (p == 1) {
return x;
}
long long ans = 1;
for (long long i = 1; i <= y; i++) {
if (1LL * ans * p > Nmax) {
return -1;
}
ans *= p;
}
if (1LL * x * ans > Nmax) {
return -1;
}
return x * ans;
}
long long Pow_log(long long x, long long p) {
long long ans = 1;
while (p) {
if (p % 2) {
ans = (1LL * ans * x) % MOD;
p--;
} else {
x = (1LL * x * x) % MOD;
p >>= 1;
}
}
return ans;
}
void solve() {
long long t, n, p;
cin >> n >> p;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
fr[a[i]]++;
}
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
long long new_n = 1;
for (long long i = 2; i <= n; i++) {
if (a[i] != a[i - 1]) {
a[++new_n] = a[i];
}
}
n = new_n;
long long pos = 1, dif = 0;
while (pos <= n) {
if (fr[a[pos]] % 2 == 0) {
pos++;
continue;
}
long long x = a[pos];
long long cnt_need = 1, is_good = 0;
for (long long i = pos + 1; i <= n; i++) {
long long new_cnt_need = do_calc(cnt_need, p, (x - a[i]));
if (new_cnt_need == -1) {
break;
}
if (new_cnt_need <= fr[a[i]]) {
fr[a[i]] -= new_cnt_need;
pos = i;
is_good = 1;
break;
} else {
cnt_need = new_cnt_need - fr[a[i]];
x = a[i];
}
}
if (!is_good) {
dif = Pow_log(p, a[pos]);
for (long long i = pos + 1; i <= n; i++) {
dif -= (1LL * fr[a[i]] * Pow_log(p, a[i])) % MOD;
if (dif < 0) {
dif += MOD;
}
}
break;
}
}
cout << dif << "\n";
for (long long i = 1; i <= n; i++) {
fr[a[i]] = 0;
}
return;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, x[N], y[N], a[N], b[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]), a[i] = x[i], b[i] = y[i];
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + n);
int mid = 1 + n >> 1;
bool f1 = 0, f2 = 0, f3 = 0;
int mn = min(a[mid + 1] - a[mid], b[mid + 1] - b[mid]);
long long ans = 0;
if (n & 1) mn = min(mn, min(a[mid] - a[mid - 1], b[mid] - b[mid - 1]));
for (int i = 1; i <= n; i++) {
ans += 1ll * abs(a[i] - a[mid]) + abs(b[i] - b[mid]);
if (x[i] > a[mid] && y[i] <= b[mid]) f1 = 1;
if (x[i] > a[mid] && y[i] > b[mid]) f2 = 1;
if (x[i] == a[mid] && y[i] == b[mid]) f3 = 1;
}
if ((f3 || n % 2 == 0) && f1 && f2) ans -= mn;
printf("%lld\n", ans * 2);
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100], second, b[20][20], r[5], c[5];
inline int calc() {
int res = 0;
memset(r, 0, sizeof(r));
memset(c, 0, sizeof(c));
int d1 = 0, d2 = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
r[i] += b[i][j];
c[j] += b[i][j];
if (i == j) d1 += b[i][j];
if (i + j == n + 1) d2 += b[i][j];
}
}
for (int i = 1; i <= n; ++i)
res = max(res, max(abs(second - r[i]), abs(second - c[i])));
res = max(res, max(abs(second - d1), abs(second - d2)));
return res;
}
void print() {
printf("%d\n", second);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
printf("%d ", b[i][j]);
}
puts("");
}
exit(0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n * n; ++i) {
scanf("%d", &a[i]);
second += a[i];
}
second /= n;
if (n == 1) {
printf("%d\n%d", second, a[1]);
return 0;
}
int m = n * n;
srand(time(0));
while (true) {
random_shuffle(a + 1, a + n * n + 1);
int v = 0;
for (int i = 1; i <= m; ++i) {
if (i % n == 1) ++v;
int x = (i % n);
if (x == 0) x = n;
b[v][x] = a[i];
}
int t = calc();
for (int it = 0; it < 500; ++it) {
int i = rand() % m + 1, j = rand() % m + 1;
int x = (i + n - 1) / n, y = i % n;
if (y == 0) y = n;
int xx = (j + n - 1) / n, yy = j % n;
if (yy == 0) yy = n;
swap(b[x][y], b[xx][yy]);
int tt = calc();
if (tt < t)
t = tt;
else
swap(b[x][y], b[xx][yy]);
if (t == 0) print();
}
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long nodeS[70], valueS[70];
long long po[70];
int getL(long long x) {
int lvl = 1;
while (x != 1) {
x /= 2;
lvl++;
}
return lvl;
}
int main() {
po[1] = 1;
for (int i = 2; i < 65; i++) {
po[i] = po[i - 1] * 2;
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int t;
long long x, k;
scanf("%d %lld", &t, &x);
if (t == 1) {
scanf("%lld", &k);
int level = getL(x);
valueS[level] = (valueS[level] + (k % po[level]) + po[level]) % po[level];
} else if (t == 2) {
scanf("%lld", &k);
int level = getL(x);
nodeS[level] = (nodeS[level] + (k % po[level]) + po[level]) % po[level];
} else {
vector<long long> ans;
long long cum = 0;
long long mult = 2;
int level = 1;
stack<long long> st;
while (mult <= x) {
cum = (cum * 2) % po[level];
cum += nodeS[level];
st.push(cum + valueS[level]);
level++;
mult *= 2;
}
st.push((cum * 2 + valueS[level] + nodeS[level]) % po[level]);
long long node =
(x - po[level] + (st.top() % po[level]) + po[level]) % po[level] +
po[level];
if (node != 1) {
ans.push_back(x);
st.pop();
node /= 2;
level--;
}
while (node != 1) {
long long back = st.top();
st.pop();
long long valueA =
(node - po[level] - (back % po[level]) + po[level]) % po[level] +
po[level];
ans.push_back(valueA);
node /= 2;
level--;
}
ans.push_back(node);
for (int i = 0; i < (int)ans.size(); i++) {
printf("%lld ", ans[i]);
}
printf("\n");
}
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
template <class Info = int, class T = int>
struct ColorUpdate {
public:
struct Range {
Range(T _l = 0) : l(_l) {}
Range(T _l, T _r, Info _v) : l(_l), r(_r), v(_v) {}
T l, r;
Info v;
bool operator<(const Range &b) const { return l < b.l; }
};
std::vector<Range> erase(T l, T r) {
std::vector<Range> ans;
if (l >= r) return ans;
auto it = ranges.lower_bound(l);
if (it != ranges.begin()) {
it--;
if (it->r > l) {
auto cur = *it;
ranges.erase(it);
ranges.insert(Range(cur.l, l, cur.v));
ranges.insert(Range(l, cur.r, cur.v));
}
}
it = ranges.lower_bound(r);
if (it != ranges.begin()) {
it--;
if (it->r > r) {
auto cur = *it;
ranges.erase(it);
ranges.insert(Range(cur.l, r, cur.v));
ranges.insert(Range(r, cur.r, cur.v));
}
}
for (it = ranges.lower_bound(l); it != ranges.end() && it->l < r; it++) {
ans.push_back(*it);
}
ranges.erase(ranges.lower_bound(l), ranges.lower_bound(r));
return ans;
}
std::vector<Range> upd(T l, T r, Info v) {
auto ans = erase(l, r);
ranges.insert(Range(l, r, v));
return ans;
}
bool exists(T x) {
auto it = ranges.upper_bound(x);
if (it == ranges.begin()) return false;
it--;
return it->l <= x && x < it->r;
}
std::set<Range> ranges;
};
struct CrazySet {
ColorUpdate<bool, long long> ranges;
bool inverted = false;
long long lazy = 0;
void addLazy(long long x) { lazy += x; }
void invert() {
lazy = -lazy;
inverted = !inverted;
}
void addRange(long long l, long long r) {
if (!inverted) {
ranges.upd(l - lazy, r - lazy, true);
} else {
ranges.upd(-r + 1 + lazy, -l + 1 + lazy, true);
}
}
void removeRange(long long l, long long r) {
if (!inverted) {
ranges.erase(l - lazy, r - lazy);
} else {
ranges.erase(-r + 1 + lazy, -l + 1 + lazy);
}
}
bool exists(long long x) {
if (!inverted) {
return ranges.exists(x - lazy);
} else {
return ranges.exists(-x + lazy);
}
}
bool empty() { return ranges.ranges.empty(); }
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int t;
std::cin >> t;
const int INF = 1e9;
while (t--) {
int n;
std::cin >> n;
CrazySet wtf;
int ans = 0;
while (n--) {
int x;
std::cin >> x;
wtf.removeRange(x, INF);
if (wtf.empty()) {
wtf.addRange(1, x);
ans++;
}
wtf.invert();
wtf.addLazy(x);
if (x % 2 == 0) {
if (wtf.exists(x / 2)) {
wtf.removeRange(1, INF);
wtf.addRange(x / 2, x / 2 + 1);
} else {
ans++;
wtf.addRange(x / 2, x / 2 + 1);
}
} else {
ans++;
}
}
std::cout << ans << '\n';
}
}
| 24
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.