solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int a, b, n;
cin >> a >> b >> n;
int p;
int digit = -1;
for (int i = 0; i <= 9; i++) {
p = a;
p *= 10;
p += i;
if (p % b == 0) {
digit = i;
break;
}
}
if (digit == -1) {
cout << "-1\n";
} else {
cout << p;
for (int i = 0; i < n - 1; i++) {
cout << "0";
}
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int side(int a, int b, int c, int x, int y) {
long long s = (long long)a * x + (long long)b * y + c;
if (s > 0) return 1;
if (s == 0) return 0;
if (s < 0) return -1;
}
int main() {
int x1, y1, x2, y2, n, cnt = 0;
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &n);
for (int i = 1; i <= n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (side(a, b, c, x1, y1) * side(a, b, c, x2, y2) < 0) cnt++;
}
printf("%d\n", cnt);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void printVec(vector<int> &v) {
for (int i = 0; i < (int)v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
int main() {
int t, n, x;
vector<int> testCase;
cin >> t;
while (t) {
cin >> n;
int maximum = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> x;
maximum = max(maximum, x);
testCase.push_back(x);
}
vector<int> counter(maximum + 1, 0);
for (int i = 0; i < n; i++) {
counter[testCase[i]] += 1;
}
int i = 0;
int j = 0;
while (i <= maximum and counter[i] >= 2) {
i++;
j++;
}
while (i <= maximum and counter[i] >= 1) {
i++;
}
cout << i + j << endl;
testCase.clear();
counter.clear();
t--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
long long int cal_black(long long int x1, long long int y1, long long int x2,
long long int y2) {
long long int total = (x2 - x1 + 1) * (y2 - y1 + 1);
if ((x2 - x1 + 1) % 2 == 0 || (y2 - y1 + 1) % 2 == 0) return total / 2;
if ((x1 + y1) % 2 == 0) return total / 2;
return total / 2 + 1;
}
long long int cal_white(long long int x1, long long int y1, long long int x2,
long long int y2) {
long long int total = (x2 - x1 + 1) * (y2 - y1 + 1);
if ((x2 - x1 + 1) % 2 == 0 || (y2 - y1 + 1) % 2 == 0) return total / 2;
if ((x1 + y1) % 2 == 0) return total / 2 + 1;
return total / 2;
}
int main() {
int t;
long long int n, m, x1, x2, x3, x4, y1, y2, y3, y4, total, black, white, tmp;
scanf("%d", &t);
while (t--) {
scanf("%lld %lld", &n, &m);
scanf("%lld %lld %lld %lld", &x1, &y1, &x2, &y2);
scanf("%lld %lld %lld %lld", &x3, &y3, &x4, &y4);
total = n * m;
white = black = total / 2;
if (total % 2 == 1) ++white;
tmp = -1;
if (x1 < x3 && y3 <= y1 && y1 <= y4) {
if (x3 <= x2 && x2 <= x4 && y3 <= y2 && y2 <= y4)
tmp = cal_black(x1, y1, x3 - 1, y2);
else if (x4 < x2 && y3 <= y2 && y2 <= y4)
tmp = cal_black(x1, y1, x3 - 1, y2) + cal_black(x4 + 1, y1, x2, y2);
else if (x3 <= x2 && x2 <= x4 && y4 < y2)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x3, y1, x2, y4);
else if (x4 < x2 && y4 < y2)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x3, y1, x4, y4);
} else if (x3 <= x1 && x1 <= x4 && y3 <= y1 && y1 <= y4) {
if (x3 <= x2 && x2 <= x4 && y3 <= y2 && y2 <= y4)
tmp = 0;
else if (x4 < x2 && y3 <= y2 && y2 <= y4)
tmp = cal_black(x4 + 1, y1, x2, y2);
else if (x3 <= x2 && x2 <= x4 && y4 < y2)
tmp = cal_black(x1, y4 + 1, x2, y2);
else if (x4 < x2 && y4 < y2)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x1, y1, x4, y4);
} else if (x1 < x3 && y1 < y3) {
if (x3 <= x2 && x2 <= x4 && y3 <= y2 && y2 <= y4)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x3, y3, x2, y2);
else if (x4 < x2 && y3 <= y2 && y2 <= y4)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x3, y3, x4, y2);
else if (x3 <= x2 && x2 <= x4 && y4 < y2)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x3, y3, x2, y4);
else if (x4 < x2 && y4 < y2)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x3, y3, x4, y4);
} else if (x3 <= x1 && x1 <= x4 && y1 < y3) {
if (x3 <= x2 && x2 <= x4 && y3 <= y2 && y2 <= y4)
tmp = cal_black(x1, y1, x2, y3 - 1);
else if (x4 < x2 && y3 <= y2 && y2 <= y4)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x1, y3, x4, y2);
else if (x3 <= x2 && x2 <= x4 && y4 < y2)
tmp = cal_black(x1, y1, x2, y3 - 1) + cal_black(x1, y4 + 1, x2, y2);
else if (x4 < x2 && y4 < y2)
tmp = cal_black(x1, y1, x2, y2) - cal_black(x1, y3, x4, y4);
}
if (tmp == -1) tmp = cal_black(x1, y1, x2, y2);
white += tmp;
black -= tmp;
white -= cal_white(x3, y3, x4, y4);
black += cal_white(x3, y3, x4, y4);
printf("%lld %lld\n", white, black);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using VV = vector<vector<T>>;
template <class T>
inline T SMIN(T &a, const T b) {
return a = (a > b) ? b : a;
}
template <class T>
inline T SMAX(T &a, const T b) {
return a = (a < b) ? b : a;
}
template <class Iter>
void dumpc(Iter begin, Iter end) {
if (false) {
for (; begin != end; ++begin) {
cerr << *begin << ',';
}
cerr << endl;
}
}
const int MAX_N = 3010 + 1;
string W1[MAX_N], W2[MAX_N];
int N;
namespace RollingHash {
template <int MOD>
struct ModInt {
unsigned int val;
ModInt() : val(0) {}
ModInt(int v) { norm(v % MOD); }
ModInt(long long v) { norm(v % MOD); }
ModInt &norm(long long v) {
v = v < 0 ? v % MOD + MOD : v;
v = v >= MOD ? v - MOD : v;
val = (unsigned int)v;
return *this;
}
explicit operator bool() const { return val != 0; }
ModInt operator-() const { return ModInt(0) - *this; }
ModInt &operator+=(ModInt that) { return norm((long long)val + that.val); }
ModInt &operator-=(ModInt that) { return norm((long long)val - that.val); }
ModInt &operator*=(ModInt that) {
val = (unsigned long long)val * that.val % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inv(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt pow(long long n) const {
ModInt x = *this, res = 1;
while (n > 0) {
if (n & 1) res *= x;
x *= x, n >>= 1;
}
return res;
}
ModInt inv() const { return (*this).pow(MOD - 2); }
bool operator==(ModInt that) const { return val == that.val; }
bool operator!=(ModInt that) const { return val != that.val; }
};
const int MOD0 = 1e9 + 7, MOD1 = 1e9 + 9;
using M0 = ModInt<MOD0>;
using M1 = ModInt<MOD1>;
M0 p0 = rand() % MOD0, pinv0 = p0.inv();
M1 p1 = rand() % MOD1, pinv1 = p1.inv();
vector<M0> P0{1}, PINV0{1};
vector<M1> P1{1}, PINV1{1};
struct H {
vector<pair<M0, M1>> hcum;
string str;
H(string s) : str(s) {
int N = (int)s.size();
while ((int)P0.size() <= N) {
P0.push_back(P0.back() * p0);
PINV0.push_back(PINV0.back() * pinv0);
P1.push_back(P1.back() * p1);
PINV1.push_back(PINV1.back() * pinv1);
}
hcum.resize(N + 1);
hcum[0] = {M0(0), M1(0)};
for (int i = 0; i < N; ++i) {
hcum[i + 1] = {hcum[i].first + M0(s[i]) * P0[i],
hcum[i].second + M1(s[i]) * P1[i]};
}
}
pair<M0, M1> hash(int r) { return {hcum[r].first, hcum[r].second}; }
pair<M0, M1> hash(int l, int r) {
return {(hcum[r].first - hcum[l].first) * PINV0[l],
(hcum[r].second - hcum[l].second) * PINV1[l]};
}
};
vector<int> match(H &s, H &p) {
int N = s.str.size(), M = p.str.size();
auto pp = p.hash(0, M);
vector<int> res;
for (int i = 0; i <= N - M; ++i)
if (s.hash(i, i + M) == pp) res.push_back(i);
return res;
}
}; // namespace RollingHash
struct RollingHash2 {
static const long long mo0 = 1000000021, mo1 = 1000000009;
static long long mul0, mul1;
static const long long add0 = 1000010007, add1 = 1003333331;
static vector<long long> pmo[2];
string s;
int l;
vector<long long> hash_[2];
void init(string s) {
this->s = s;
l = s.size();
hash_[0] = hash_[1] = vector<long long>(1, 0);
if (!mul0)
mul0 = 10009 + (((long long)&mul0) >> 5) % 259,
mul1 = 10007 + (((long long)&mul1) >> 5) % 257;
if (pmo[0].empty()) pmo[0].push_back(1), pmo[1].push_back(1);
for (int i = 0; i < (l); ++i)
hash_[0].push_back((hash_[0].back() * mul0 + add0 + s[i]) % mo0);
for (int i = 0; i < (l); ++i)
hash_[1].push_back((hash_[1].back() * mul1 + add1 + s[i]) % mo1);
}
pair<long long, long long> hash(int l, int r) {
if (l > r) return make_pair(0, 0);
while (pmo[0].size() < r + 2)
pmo[0].push_back(pmo[0].back() * mul0 % mo0),
pmo[1].push_back(pmo[1].back() * mul1 % mo1);
return make_pair(
(hash_[0][r + 1] + (mo0 - hash_[0][l] * pmo[0][r + 1 - l] % mo0)) % mo0,
(hash_[1][r + 1] + (mo1 - hash_[1][l] * pmo[1][r + 1 - l] % mo1)) %
mo1);
}
pair<long long, long long> hash(string s) {
init(s);
return hash(0, s.size() - 1);
}
static pair<long long, long long> concat(pair<long long, long long> L,
pair<long long, long long> R,
int RL) {
while (pmo[0].size() < RL + 2)
pmo[0].push_back(pmo[0].back() * mul0 % mo0),
pmo[1].push_back(pmo[1].back() * mul1 % mo1);
return make_pair((R.first + L.first * pmo[0][RL]) % mo0,
(R.second + L.second * pmo[1][RL]) % mo1);
}
};
vector<long long> RollingHash2::pmo[2];
long long RollingHash2::mul0, RollingHash2::mul1;
vector<int> buildPrefixFunction(const string S) {
int L = S.size();
vector<int> pi(L + 1, -1);
int j = -1;
for (int i = 0; i < L; ++i) {
while (j >= 0 && S[i] != S[j]) j = pi[j];
pi[i + 1] = ++j;
}
return pi;
}
vector<int> doKMP(string s, string p) {
vector<int> res;
vector<int> pi = buildPrefixFunction(p);
int j = 0, L = s.size(), M = p.size();
for (int i = 0; i < L; ++i) {
while (j >= 0 && s[i] != p[j]) j = pi[j];
++j;
if (j >= M) {
res.push_back(i - j + 1);
j = pi[j];
}
}
return res;
}
void end() {
fprintf(stdout, "NO"), putchar('\n');
;
exit(0);
}
pair<int, int> boundary2(string s, string t, int l, int r) {
int resl = 0, resr = 0, M = int((s).size());
int j = l - 1;
for (; j >= 0; --j) {
if (s[j] != t[j]) break;
}
resl = l - j - 1;
assert(resl >= 0);
j = r + 1;
for (; j < M; ++j)
if (s[j] != t[j]) break;
resr = j - r - 1;
assert(resr >= 0);
return {resl, resr};
}
int si = -1, sp = -1;
pair<int, int> boundary1(string s, string t, int l, int r, string x) {
int resl = 0, resr = 0, M = int((s).size());
int j = l - 1;
for (; j >= 0; --j) {
int d = l - j;
if (s[j] != t[j] || sp - d < 0 || s[j] != W1[si][sp - d]) break;
}
resl = l - j - 1;
assert(resl >= 0);
j = r + 1;
for (; j < M; ++j) {
int d = j - r;
int jj = sp + int((x).size()) + d - 1;
if (s[j] != t[j] || jj >= int((W1[si]).size()) || s[j] != W1[si][jj]) break;
}
resr = j - r - 1;
assert(resr >= 0);
return {resl, resr};
}
void solve_wrong() {
string s = "", t = "";
int lb, rb;
for (int i = 0; i < (N); ++i) {
int M = int((W1[i]).size());
int l = 3010, r = -1;
for (int j = 0; j < (M); ++j)
if (W1[i][j] != W2[i][j]) SMIN(l, j), SMAX(r, j);
if (r != -1) {
if (s.empty()) {
s = W1[i].substr(l, r - l + 1);
t = W2[i].substr(l, r - l + 1);
lb = l, rb = int((W1[i]).size()) - r - 1;
sp = l, si = i;
} else {
if (r - l + 1 != int((s).size())) end();
int L = int((s).size());
for (int j = 0; j < (L); ++j) {
if (W1[i][l + j] != s[j]) end();
if (W2[i][l + j] != t[j]) end();
}
auto p = boundary1(W1[i], W2[i], l, r, s);
SMIN(lb, p.first);
SMIN(rb, p.second);
}
} else {
vector<int> ps = doKMP(W1[i], s);
if (ps.empty()) continue;
int j = ps.front();
auto p = boundary2(W1[i], W2[i], j, j + int((s).size()) - 1);
if (p.first >= lb && p.second >= rb) end();
}
}
if (s.empty()) {
s += W1[0][0], t += W1[0][0];
} else {
if (false) {
cerr << "s"
<< " = " << (s) << ", "
<< "t"
<< " = " << (t) << ", "
<< "lb"
<< " = " << (lb) << ", "
<< "rb"
<< " = " << (rb) << endl;
};
if (false) {
cerr << "sp"
<< " = " << (sp) << ", "
<< "si"
<< " = " << (si) << ", "
<< "W1[si]"
<< " = " << (W1[si]) << ", "
<< "W2[si]"
<< " = " << (W2[si]) << endl;
};
s = W1[si].substr(sp - lb, lb + rb + int((s).size()));
t = W2[si].substr(sp - lb, lb + rb + int((t).size()));
}
fprintf(stdout, "YES"), putchar('\n');
;
fprintf(stdout, "%s", s.c_str()), putchar('\n');
;
fprintf(stdout, "%s", t.c_str()), putchar('\n');
;
}
pair<int, int> boundary(string s, string t, int l, int r) {
int resl = 0, resr = 0, M = int((s).size());
string u = W1[si];
int j = l - 1;
for (; j >= 0; --j) {
int d = l - j;
if (sp - d < 0 || s[j] != u[sp - d]) break;
}
resl = l - j - 1;
assert(resl >= 0);
j = r + 1;
for (; j < M; ++j) {
int d = j - r;
int jj = sp + r - l + d;
if (jj >= int((u).size()) || s[j] != u[jj]) break;
}
resr = j - r - 1;
assert(resr >= 0);
return {resl, resr};
}
void solve() {
string s = "", t = "", pre = "", post = "";
int lb, rb;
for (int i = 0; i < (N); ++i) {
int M = int((W1[i]).size());
if (false) {
cerr << "i"
<< " = " << (i) << ", "
<< "M"
<< " = " << (M) << endl;
};
int l = 3010, r = -1;
for (int j = 0; j < (M); ++j)
if (W1[i][j] != W2[i][j]) SMIN(l, j), SMAX(r, j);
if (r != -1) {
string ss = W1[i].substr(l, r - l + 1);
string tt = W2[i].substr(l, r - l + 1);
string prepre = W1[i].substr(0, l);
string postpost = W2[i].substr(r + 1);
reverse((prepre).begin(), (prepre).end());
if (s.empty()) {
s = ss, t = tt, pre = prepre, post = postpost;
lb = l, rb = int((W1[i]).size()) - r - 1;
sp = l, si = i;
} else {
if (r - l + 1 != int((s).size())) end();
int L = int((s).size());
for (int j = 0; j < (L); ++j) {
if (W1[i][l + j] != s[j]) end();
if (W2[i][l + j] != t[j]) end();
}
auto p = boundary(W1[i], W2[i], l, r);
SMIN(lb, p.first);
SMIN(rb, p.second);
}
}
}
s = W1[si].substr(sp - lb, lb + rb + int((s).size()));
t = W2[si].substr(sp - lb, lb + rb + int((t).size()));
for (int i = 0; i < (N); ++i) {
string x = W1[i], y = W2[i];
vector<int> ps = doKMP(x, s);
if (ps.empty()) continue;
int j = ps.front();
int M = int((x).size());
assert(j + int((s).size()) <= M);
for (int o = 0; o < (int((s).size())); ++o) {
assert(x[j + o] == s[o]);
x[j + o] = t[o];
}
if (x != y) end();
}
fprintf(stdout, "YES"), putchar('\n');
;
fprintf(stdout, "%s", s.c_str()), putchar('\n');
;
fprintf(stdout, "%s", t.c_str()), putchar('\n');
;
}
RollingHash2 rh[3030];
void solve_inspired_by_kmjp() {
string s = "", t = "", pre = "", post = "";
for (int i = 0; i < (N); ++i) {
int M = int((W1[i]).size());
int l = 3010, r = -1;
for (int j = 0; j < (M); ++j)
if (W1[i][j] != W2[i][j]) SMIN(l, j), SMAX(r, j);
if (r != -1) {
string ss = W1[i].substr(l, r - l + 1);
string tt = W2[i].substr(l, r - l + 1);
string prepre = W1[i].substr(0, l);
string postpost = W2[i].substr(r + 1);
reverse((prepre).begin(), (prepre).end());
if (s.empty()) {
s = ss, t = tt, pre = prepre, post = postpost;
} else {
if (ss != s || tt != t) {
if (false) {
cerr << "ss"
<< " = " << (ss) << ", "
<< "s"
<< " = " << (s) << ", "
<< "tt"
<< " = " << (tt) << ", "
<< "t"
<< " = " << (t) << endl;
};
end();
}
for (int j = 0; j < (int((pre).size())); ++j)
if (j >= int((prepre).size()) || prepre[j] != pre[j]) {
pre.resize(j);
break;
}
for (int j = 0; j < (int((post).size())); ++j)
if (j >= int((postpost).size()) || postpost[j] != post[j]) {
post.resize(j);
break;
}
}
}
}
if (false) {
cerr << "s"
<< " = " << (s) << ", "
<< "t"
<< " = " << (t) << ", "
<< "pre"
<< " = " << (pre) << ", "
<< "post"
<< " = " << (post) << endl;
};
reverse((pre).begin(), (pre).end());
s = pre + s + post;
t = pre + t + post;
auto ha = rh[N].hash(s);
for (int i = 0; i < (N); ++i) {
rh[i].init(W1[i]);
string x = W1[i], y = W2[i];
for (int j = 0; j + s.size() <= x.size(); j++) {
if (rh[i].hash(j, j + s.size() - 1) == ha) {
x = x.substr(0, j) + t + x.substr(s.size() + j);
break;
}
}
if (x != y) end();
}
fprintf(stdout, "YES"), putchar('\n');
;
fprintf(stdout, "%s", s.c_str()), putchar('\n');
;
fprintf(stdout, "%s", t.c_str()), putchar('\n');
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
scanf("%d", &N);
if (false) {
cerr << "N"
<< " = " << (N) << endl;
};
for (int i = 0; i < (N); ++i) {
char c[3010];
scanf("%s", c);
W1[i] = string(c);
}
for (int i = 0; i < (N); ++i) {
char c[3010];
scanf("%s", c);
W2[i] = string(c);
}
solve_inspired_by_kmjp();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
int a[maxn], b[maxn];
int dp[2][maxn][55][55];
inline int ip(int k) { return k > 0 ? k : 0; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, p, k;
cin >> n >> p >> k;
int r, s;
cin >> r;
for (int i = 0; i < r; i++) {
int t;
cin >> t;
a[t] = 1;
}
cin >> s;
for (int i = 0; i < s; i++) {
int t;
cin >> t;
b[t] = 1;
}
p = min(p, (2 * n) / k + 2 * (2 * n % k != 0));
int f = 0;
memset(dp, -0x3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= p; j++) {
for (int x = 0; x < k; x++) {
for (int y = 0; y < k; y++) {
dp[!f][j][ip(x - 1)][ip(y - 1)] =
max(dp[!f][j][ip(x - 1)][ip(y - 1)],
dp[f][j][x][y] + ((x > 0 && a[i]) || (y > 0 && b[i])));
dp[!f][j + 1][k - 1][ip(y - 1)] =
max(dp[!f][j + 1][k - 1][ip(y - 1)],
dp[f][j][x][y] + (a[i] || (y > 0 && b[i])));
dp[!f][j + 1][ip(x - 1)][k - 1] =
max(dp[!f][j + 1][ip(x - 1)][k - 1],
dp[f][j][x][y] + (b[i] || (x > 0 && a[i])));
}
}
}
memset(dp[f], -0x3f, sizeof(dp[f]));
f = !f;
}
int ans = 0;
for (int l = 0; l <= p; l++)
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) ans = max(ans, dp[f][l][i][j]);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long INF = 1000000000;
template <class T>
inline void read(T& x) {
char c;
int flag = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag *= -1;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= flag;
return;
}
int arr[200005];
inline bool check(int mid, string a, string b) {
bool vis[200005];
memset(vis, 0, sizeof vis);
;
for (int i = 1; i <= mid; ++i) vis[arr[i] - 1] = 1;
int g = 0;
for (int i = 0; i < a.length() && g < b.length(); ++i) {
if (vis[i]) continue;
if (a[i] == b[g]) g++;
}
return g == b.length();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string a, b;
cin >> a >> b;
for (int i = 1; i <= a.length(); ++i) cin >> arr[i];
int l = 1, r = a.length(), ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid, a, b))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n, s, t, p, x, y, last[maxn], a[maxn], b[maxn], r[maxn], d[maxn];
vector<int> g, h, A, B;
pair<int, int> o = {maxn, 0};
struct Edge {
int v, nxt;
} e[2 * maxn];
int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + (c ^ 48), c = getchar();
return x;
}
inline void add(int u, int v) {
static int cnt = 0;
e[++cnt] = {v, last[u]}, last[u] = cnt;
}
bool dfs1(int u, int fa) {
g.push_back(u);
if (u == t) return 1;
for (int i = last[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
if (dfs1(v, u)) return 1;
}
g.pop_back();
return 0;
}
void dfs2(int u, int fa, int d) {
if (a[u] != b[u]) {
h.push_back(u), r[u] = 1;
if (d - 1 == o.first && fa != o.second) printf("-1\n"), exit(0);
;
if (d - 1 < o.first) o = {d - 1, fa};
}
for (int i = last[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs2(v, u, d + 1);
}
}
void dfs3(int u, int fa) {
if (u != p) A.push_back(a[u]), B.push_back(b[u]);
for (int i = last[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
if (r[v]) dfs3(v, u);
}
}
int dfs4(int u, int fa, int d, int t) {
if (u == t) return d;
for (int i = last[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
int ret = dfs4(v, u, d + 1, t);
if (ret) return ret;
}
return 0;
}
int calc(vector<int> A, vector<int> B) {
int pos = 0, siz = A.size();
for (int i = 0; i < B.size(); i++)
if (B[i] == A[0]) pos = i;
if (!pos) return 0;
for (int i = 0; i < A.size(); i++)
if (A[i] != B[(i + pos) % siz]) return 0;
return pos;
}
inline int S(int x, int y) { return dfs4(x, 0, 0, y); }
inline long long get(int x, int y) {
int c = calc(A, B);
return S(s, x) + 1ll * (c - 1) * (A.size() + 1) + S(y, t) + 1;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read(), s = a[i] ? s : i;
for (int i = 1; i <= n; i++) b[i] = read(), t = b[i] ? t : i;
for (int i = 1; i < n; i++) {
x = read(), y = read();
add(x, y), add(y, x);
}
dfs1(s, 0);
for (int i = 1; i < g.size(); i++) swap(a[g[i - 1]], a[g[i]]);
bool flag = 1;
for (int i = 1; i <= n; i++) flag &= a[i] == b[i];
if (flag) {
printf("0 %d\n", g.size() - 1);
return 0;
}
dfs2(t, 0, 0);
h.push_back(p = o.second);
r[p] = 1;
for (int i = 0; i < h.size(); i++) {
int u = h[i];
for (int j = last[u]; j; j = e[j].nxt) {
int v = e[j].v;
if (r[v]) d[u]++;
}
}
vector<int> c;
for (int i = 0; i < h.size(); i++) {
int u = h[i];
if (d[u] == 1)
c.push_back(u);
else if (d[u] != 2)
printf("-1\n"), exit(0);
;
}
if (c.size() != 2) printf("-1\n"), exit(0);
;
if (c[0] > c[1]) swap(c[0], c[1]);
dfs3(c[0], 0);
if (!calc(A, B)) printf("-1\n"), exit(0);
;
printf("%d %d ", c[0], c[1]);
long long ans = get(c[0], c[1]);
reverse(A.begin(), A.end());
reverse(B.begin(), B.end());
ans = min(ans, get(c[1], c[0]));
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
const int INF = 1000000007;
const int MAXN = 2751000;
const int mod = 1000000000;
const double EPS = 1e-6;
using namespace std;
int maxv = -INF, minv = INF;
int n, m, t;
int maxd[MAXN], p[MAXN], mask[MAXN];
int nump[MAXN], b[400004];
int x;
vector<int> ans;
void find_maxd() {
for (int i = 2; i < MAXN; i++)
if (maxd[i] == 0)
for (int j = i; j < MAXN; j += i)
if (maxd[j] == 0) maxd[j] = j / i;
return;
};
void find_p() {
for (int i = 2; i < MAXN; i++)
if (p[i] == 0)
for (unsigned long long j = (unsigned long long)i * i; j < MAXN; j += i)
p[j] = 1;
return;
};
void find_nump() {
for (int i = 2, k = 1; i < MAXN; i++)
if (p[i] == 0) nump[i] = k++;
return;
};
int main() {
find_maxd();
find_p();
find_nump();
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) {
scanf("%d", &b[i]);
mask[b[i]]++;
}
for (int i = MAXN; i >= 0; i--) {
while (mask[i] > 0) {
if (p[i] != 0) {
ans.push_back(i);
mask[maxd[i]]--;
} else {
ans.push_back(nump[i]);
mask[nump[i]]--;
}
mask[i]--;
}
}
for (auto i : ans) printf("%d ", i);
cout << '\n';
return 0;
};
| 5 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 19;
int n, a[maxn];
long long k, b[maxn];
inline long long calc(int a, int x) { return -3ll * x * x + 3ll * x + a - 1; }
long long get(int i, long long x) {
long long l = 0, r = a[i];
while (l < r) {
long long mid = (l + r + 1) >> 1;
if (calc(a[i], mid) >= x)
l = mid;
else
r = mid - 1;
}
return l;
}
long long check(long long x) {
long long res = 0ll;
for (int i = 1; i <= n; ++i) res += get(i, x);
return res;
}
int main() {
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
long long l = -3e18, r = 3e18;
while (l < r) {
long long mid = (l + r) >> 1;
if (check(mid) < k)
r = mid;
else
l = mid + 1;
}
for (int i = 1; i <= n; ++i) b[i] = get(i, l), k -= b[i];
for (int i = 1; i <= n; ++i) {
long long d = get(i, l - 1) - b[i], h = std::min(k, d);
k -= h, b[i] += h;
}
for (int i = 1; i <= n; ++i) printf("%lld ", b[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t-- > 0) {
int l, r;
cin >> l >> r;
cout << l << " " << 2 * l << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
float x[1001], y[1001], v[1001], waktu[1001];
int main() {
float a, b, jarak, n, minimal;
int i;
minimal = INT_MAX;
cin >> a >> b;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x[i] >> y[i] >> v[i];
}
jarak = sqrt(pow((x[1] - a), 2) + pow((y[1] - b), 2));
waktu[1] = jarak / v[1];
minimal = min(waktu[1], minimal);
for (i = 2; i <= n; i++) {
jarak = sqrt(pow((x[i] - a), 2) + pow((y[i] - b), 2));
waktu[i] = jarak / v[i];
minimal = min(minimal, waktu[i]);
}
cout << fixed;
cout << setprecision(20);
cout << minimal << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t = 0;
cin >> t;
while (t--) {
int n = 0, x = 0, ans1 = INT_MAX;
cin >> n >> x;
for (int i = 0; i < n; ++i) {
int in1 = 0;
cin >> in1;
if (!(x % in1))
ans1 = min(ans1, x / in1);
else
ans1 = min(ans1, max(1, x / in1) + 1);
}
cout << ans1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1ll << 62) - 1;
const int inf = (1 << 30) - 1;
const int M = 500007;
int cnt;
int main() {
ios_base::sync_with_stdio(false);
int n, k;
string st;
cin >> n >> k;
cin >> st;
if (k == 2) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (st[i] != 'A') cnt++;
} else {
if (st[i] != 'B') cnt++;
}
}
if (cnt <= n - cnt) {
cout << cnt << endl;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
cout << "A";
else
cout << "B";
}
} else {
cout << n - cnt << endl;
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
cout << "B";
else
cout << "A";
}
}
} else {
for (int i = 1; i < n; i++) {
if (st[i - 1] == st[i]) {
for (char ch = 'A';; ch++) {
if (st[i] != ch && st[i + 1] != ch) {
st[i] = ch;
cnt++;
break;
}
}
}
}
cout << cnt << endl;
cout << st << endl;
return 0;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
double n, k;
cin >> n >> k;
double a, b;
cin >> a >> b;
n--;
double len = 0;
while (n--) {
double x, y;
cin >> x >> y;
len += ((double)sqrt(pow(x - a, 2) + pow(y - b, 2)));
a = x;
b = y;
}
len *= k;
cout << fixed << setprecision(9) << len / (double)50 << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
vector<long long> g[3500];
long long p[3500][3500];
map<pair<pair<int, int>, int>, int> blocked;
void Solve() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < k; i++) {
long long f, s, t;
cin >> f >> s >> t;
blocked[{{f, s}, t}] = 1;
}
queue<pair<int, int>> q;
q.push({1, 1});
pair<int, int> ans = {-1, -1};
while (!q.empty()) {
int u = q.front().first;
int v = q.front().second;
q.pop();
if (v == n) {
ans = {u, v};
break;
}
for (auto it : g[v]) {
if (p[v][it] || blocked[{{u, v}, it}]) continue;
p[v][it] = u;
q.push({v, it});
}
}
if (ans.first == -1) {
cout << "-1";
return;
}
vector<int> path;
while (ans.second != 1) {
path.push_back(ans.second);
ans = {p[ans.first][ans.second], ans.first};
}
path.push_back(1);
cout << path.size() - 1 << '\n';
reverse(path.begin(), path.end());
for (auto it : path) cout << it << ' ';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
Solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 6e5 + 10, MAXM = 4e6 + 10;
const int INF = INT_MAX, SINF = 0x3f3f3f3f;
const long long llINF = LLONG_MAX;
const int MOD = 1e9 + 7, mod = 998244353;
int n, m;
int a[MAXN], q[MAXN];
int l[MAXN], r[MAXN];
int t[MAXN];
int block[MAXN];
int num[MAXN], cnt, tt;
struct query {
int l, r, id;
bool operator<(const query &a) const {
return block[l] == block[a.l] ? r < a.r : l < a.l;
}
} qq[MAXN];
void add(int x) {
if (!num[x]) cnt++;
num[x]++;
}
void del(int x) {
num[x]--;
if (!num[x]) cnt--;
}
int tr[MAXN];
void ADD(int x, int val) {
while (x <= n) {
tr[x] += val;
x += x & -x;
}
}
int QUERY(int x) {
int ans = 0;
while (x) {
ans += tr[x];
x -= x & -x;
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) l[i] = r[i] = i;
for (int i = 1; i <= m; i++) l[a[i]] = 1;
for (int i = 1; i <= m; i++) {
if (q[a[i]])
qq[++tt] = {q[a[i]], i, a[i]};
else {
r[a[i]] = max(r[a[i]], a[i] + QUERY(n - a[i]));
ADD(n - a[i] + 1, 1);
}
q[a[i]] = i;
}
for (int i = 1; i <= n; i++)
if (q[a[i]]) qq[++tt] = {q[a[i]], m, a[i]};
int blocksz = sqrt(n);
for (int i = 1; i <= n; i++) block[i] = i / blocksz + 1;
sort(qq + 1, qq + tt + 1);
int lz = 1, rz = 0;
for (int i = 1; i <= tt; i++) {
while (rz < qq[i].r) add(a[++rz]);
while (rz > qq[i].r) del(a[rz--]);
while (lz < qq[i].l) del(a[lz++]);
while (lz > qq[i].l) add(a[--lz]);
r[qq[i].id] = max(r[qq[i].id], cnt);
}
int tot = n;
for (int i = n; i; i--)
if (!q[i]) r[i] = tot--;
for (int i = 1; i <= n; i++) printf("%d %d\n", l[i], r[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s1, s2;
cin >> s1 >> s2;
int ptr1 = 0, ptr2 = 0;
while (ptr1 < s1.length() && ptr2 < s2.length()) {
if (s1[ptr1] != s2[ptr2]) {
cout << "NO\n";
return;
}
int cnt1 = 1, cnt2 = 1;
while (s1[ptr1] == s1[ptr1 + 1]) {
cnt1++;
ptr1++;
}
while (s2[ptr2] == s2[ptr2 + 1]) {
cnt2++;
ptr2++;
}
if (cnt1 > cnt2) {
cout << "NO\n";
return;
}
ptr1++;
ptr2++;
}
if (ptr1 < s1.length() && ptr2 >= s2.length()) {
cout << "NO\n";
return;
}
if (ptr2 < s2.length() && s2[ptr2] != s1[ptr1 - 1]) {
cout << "NO\n";
return;
}
cout << "YES\n";
}
int main() {
int n;
cin >> n;
while (n--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, a, b;
int d[5050][5050], val[5050][5050];
void init() {
int left, right;
int x = s.size();
for (int i = 0; i < x; i++) d[i][i] = 1;
for (int len = 2; len <= x; len++)
for (int i = 0; i + len - 1 < x; i++) {
left = i, right = i + len - 1;
if (len == 2)
d[left][right] = s[left] == s[right];
else
d[left][right] = d[left + 1][right - 1] and (s[left] == s[right]);
}
for (int i = 0; i < 5030; i++) {
val[i][i] = 1;
val[i][i + 1] = 2 + d[i][i + 1];
}
for (int len = 3; len <= x; len++)
for (int i = 0; i + len - 1 < x; i++)
val[i][i + len - 1] = d[i][i + len - 1] + val[i][i + len - 2] +
val[i + 1][i + len - 1] - val[i + 1][i + len - 2];
}
int main() {
cin >> s;
init();
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
cout << val[a - 1][b - 1] << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const long double pi = acos(-1.0);
const int N = 5555;
const int INF = (int)1e9;
int u[N], v[N], n, m, k, deg[N], st, fin, st2, fin2, t, color[N];
bool used[N];
struct edge {
int tov, c, num, rev, f;
edge(int tov, int c, int num, int rev)
: tov(tov), c(c), num(num), rev(rev), f(0) {}
};
vector<edge> adj[N];
void add_edge(int u, int v, int c, int num) {
int unum = ((int)(adj[u]).size()), vnum = ((int)(adj[v]).size());
adj[u].push_back(edge(v, c, num, vnum));
adj[v].push_back(edge(u, 0, -1, unum));
}
void add_edge(int u, int v, int l, int r, int num) {
add_edge(st2, v, l, num);
add_edge(u, fin2, l, num);
add_edge(u, v, r - l, num);
}
bool dfs(int v) {
if (v == fin2) return true;
if (used[v]) return false;
used[v] = true;
for (int i = 0; i < ((int)(adj[v]).size()); ++i)
if ((adj[v][i].c - adj[v][i].f > 0) && dfs(adj[v][i].tov)) {
adj[v][i].f++;
adj[adj[v][i].tov][adj[v][i].rev].f--;
return true;
}
return false;
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &t);
st = n + m, fin = n + m + 1, st2 = n + m + 2, fin2 = n + m + 3;
for (int i = 0; i < k; ++i) {
scanf("%d%d", &u[i], &v[i]), --u[i], --v[i], v[i] += n;
deg[u[i]]++, deg[v[i]]++;
color[i] = -1;
}
int sum = 0;
for (int i = 0; i < n + m; ++i) sum += (deg[i] + t - 1) / t - (deg[i] / t);
for (int it = 0; it < t; ++it) {
for (int i = 0; i < n + m + 4; ++i) adj[i].clear();
for (int i = 0; i < n; ++i)
add_edge(st, i, deg[i] / (t - it), (deg[i] + (t - it - 1)) / (t - it),
-1);
for (int i = n; i < n + m; ++i)
add_edge(i, fin, deg[i] / (t - it), (deg[i] + (t - it - 1)) / (t - it),
-1);
add_edge(fin, st, INF, -1);
for (int i = 0; i < k; ++i) {
if (color[i] != -1) continue;
add_edge(u[i], v[i], 1, i);
}
while (true) {
memset(used, 0, sizeof(used));
if (!dfs(st2)) break;
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < ((int)(adj[i]).size()); ++j)
if ((adj[i][j].f == 1) && (adj[i][j].num != -1)) {
deg[i]--, deg[adj[i][j].tov]--;
color[adj[i][j].num] = it;
}
}
printf("%d\n", sum);
for (int i = 0; i < k; ++i) printf("%d%c", color[i] + 1, " \n"[i == k - 1]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
string p = "";
for (int k = 0; k < 2 * n - 1; k = k + 2) {
p = p + s[k];
}
cout << p << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct seg {
int lf, rt, dc;
} S[20005 << 2];
int n, m, k;
int a[55][20005];
int dp[2][20005];
int crt[2][20005], clf[2][20005], disc[2][20005];
seg merge(seg a, seg b) {
seg res;
res.lf = max(a.lf, b.lf);
res.rt = max(a.rt, b.rt);
res.dc = max(a.dc, b.dc);
return res;
}
seg get(int node, int bas, int son, int l, int r) {
if (l > r) {
return {-1000000005, -1000000005, -1000000005};
}
if (bas >= l && son <= r) return S[node];
if (((bas + son) >> 1) >= l && ((bas + son) >> 1) + 1 <= r)
return merge(get(node << 1, bas, ((bas + son) >> 1), l, r),
get(node << 1 | 1, ((bas + son) >> 1) + 1, son, l, r));
if (((bas + son) >> 1) >= l)
return get(node << 1, bas, ((bas + son) >> 1), l, r);
return get(node << 1 | 1, ((bas + son) >> 1) + 1, son, l, r);
}
void build(int node, int bas, int son, int cur) {
if (bas == son) {
S[node] = {clf[cur][bas], crt[cur][bas], disc[cur][bas]};
return;
}
build(node << 1, bas, ((bas + son) >> 1), cur);
build(node << 1 | 1, ((bas + son) >> 1) + 1, son, cur);
S[node] = merge(S[node << 1], S[node << 1 | 1]);
}
void calc(int i) {
int cur = i & 1;
for (int j = 1; j <= m - k + 1; j++) {
disc[cur][j] = dp[cur][j] + a[i + 1][j + k - 1] - a[i + 1][j - 1];
clf[cur][j] = dp[cur][j] - a[i + 1][j - 1];
crt[cur][j] = dp[cur][j] + a[i + 1][j + k - 1];
}
build(1, 1, m - k + 1, cur);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j], a[i][j] += a[i][j - 1];
for (int i = 1; i <= m - k + 1; i++) dp[1][i] = a[1][i + k - 1] - a[1][i - 1];
calc(1);
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= m - k + 1; j++) {
int cur = i & 1;
int bf = !cur;
dp[cur][j] = -1000000005;
if (j - k >= 1) {
dp[cur][j] = max(dp[cur][j], get(1, 1, m - k + 1, 1, j - k).dc +
a[i][j + k - 1] - a[i][j - 1]);
}
if (j + k <= m - k + 1) {
dp[cur][j] = max(dp[cur][j], get(1, 1, m - k + 1, j + k, m - k + 1).dc +
a[i][j + k - 1] - a[i][j - 1]);
}
int l = max(1, j - k + 1);
int r = j;
dp[cur][j] =
max(dp[cur][j], get(1, 1, m - k + 1, l, r).lf + a[i][j + k - 1]);
l = j;
r = min(m - k + 1, j + k - 1);
dp[cur][j] = max(dp[cur][j], get(1, 1, m - k + 1, l, r).rt - a[i][j - 1]);
}
calc(i);
}
printf("%d\n", *max_element(dp[n & 1] + 1, dp[n & 1] + 1 + m - k + 1));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 50;
const int maxm = 1e6 + 50;
const double eps = 1e-10;
const int max_index = 62;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
inline int read() {
char c = getchar();
while (!isdigit(c)) c = getchar();
int x = 0;
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
pair<long long, long long> P[maxn];
long long cross(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
return abs((b.first - a.first) * (c.second - a.second) -
(b.second - a.second) * (c.first - a.first));
}
int main() {
int n = read(), s = read();
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", &P[i].first, &P[i].second);
pair<long long, long long> a = P[0], b = P[1], c = P[2];
long long ans = cross(a, b, c);
int flag = 1;
while (flag) {
flag = 0;
for (int i = 1; i <= n; i++) {
long long tmp = cross(P[i], b, c);
if (tmp > ans) {
ans = tmp;
a = P[i];
flag = 1;
}
}
for (int i = 1; i <= n; i++) {
long long tmp = cross(a, P[i], c);
if (tmp > ans) {
ans = tmp;
b = P[i];
flag = 1;
}
}
for (int i = 1; i <= n; i++) {
long long tmp = cross(a, b, P[i]);
if (tmp > ans) {
ans = tmp;
c = P[i];
flag = 1;
}
}
}
cout << a.first + b.first - c.first << " " << a.second + b.second - c.second
<< "\n";
cout << a.first - b.first + c.first << " " << a.second - b.second + c.second
<< "\n";
cout << b.first + c.first - a.first << " " << b.second + c.second - a.second
<< "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, posR, posC, ans = 0;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
cin >> a;
if (a == 1) {
posR = i;
posC = j;
}
}
}
ans += abs(2 - posR) + abs(2 - posC);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double pi = acos(-1.0);
const int maxn = 100000 + 10;
const int mod = 1e9 + 7;
long long dp[500][500];
long long C[500][500];
long long fact[500];
int cnt[500];
int a[500];
int vis[500];
int sz;
int check(long long x) {
long long l = 1, r = 1e9;
long long now = l;
while (l <= r) {
long long mid = (l + r) >> 1;
if (mid * mid <= x)
now = mid, l = mid + 1;
else
r = mid - 1;
}
return now * now == x;
}
inline long long M(long long x) { return x % mod; }
void init() {
C[0][0] = 1;
fact[0] = 1;
for (int i = 1; i <= 300; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = M(C[i - 1][j] + C[i - 1][j - 1]);
}
}
for (int i = 1; i <= 300; i++) fact[i] = M(fact[i - 1] * i);
}
void slove() {
dp[0][cnt[0] - 1] = 1;
int lim = cnt[0];
for (int i = 1; i < sz; i++) {
for (int j = 0; j < lim; j++) {
for (int k = 0; k < cnt[i]; k++) {
for (int m = 0; m <= min(j, k + 1); m++) {
dp[i][j + cnt[i] - 1 - k - m] =
M(dp[i][j + cnt[i] - 1 - k - m] +
dp[i - 1][j] * C[cnt[i] - 1][k] % mod * C[j][m] % mod *
C[lim - 1 - j + 2][k + 1 - m]);
}
}
}
lim += cnt[i];
}
long long ans = dp[sz - 1][0];
for (int i = 0; i < sz; i++) {
ans *= fact[cnt[i]];
ans %= mod;
}
cout << ans << endl;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) {
for (int j = i; j < n; j++) {
if (check(1LL * a[i] * a[j])) {
cnt[sz]++;
vis[j] = 1;
}
}
sz++;
}
}
init();
slove();
return 0;
}
| 8 |
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <unordered_set>
#include <unordered_map>
#include <numeric>
#include <ctime>
#include <bitset>
#include <complex>
#include <chrono>
#include <random>
#include <functional>
using namespace std;
const int N = 501;
const int MOD = 998244353;
int mul(int a, int b) {
return 1LL * a * b % MOD;
}
int res[N];
int cnt[N];
int ban[2 * N];
int a[2 * N][N];
void solve() {
int ans = 1;
int n;
cin >> n;
fill(ban, ban + 2 * n, 0);
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
a[i][j]--;
}
}
for (int it = 0; it < n; it++) {
int some = -1;
for (int j = 0; j < n && some == -1; j++) {
fill(cnt, cnt + n, 0);
for (int i = 0; i < 2 * n; i++) {
if (!ban[i]) {
cnt[a[i][j]]++;
}
}
for (int i = 0; i < n; i++) {
if (cnt[i] == 1) {
for (int t = 0; t < 2 * n; t++) {
if (!ban[t] && a[t][j] == i) {
some = t;
break;
}
}
break;
}
}
}
if (some == -1) {
ans = mul(ans, 2);
for (int i = 0; i < 2 * n; i++) {
if (!ban[i]) {
some = i;
}
}
}
res[it] = some;
for (int i = 0; i < 2 * n; i++) {
int any = 0;
for (int j = 0; j < n; j++) {
any |= (a[i][j] == a[some][j]);
}
if (any) ban[i] = 1;
}
}
cout << ans << '\n';
for (int i = 0; i < n; i++) {
cout << res[i] + 1 << ' ';
}
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int q;
cin >> q;
while (q--) {
solve();
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 9;
long long qpow(long long a, long long b) {
long long ans = 1;
a %= MOD;
while (b) {
if (b & 1) ans = (ans * a) % MOD;
b >>= 1;
a = (a * a) % MOD;
}
return ans % MOD;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, a, b, k;
cin >> n >> a >> b >> k;
string s;
cin >> s;
long long ans = 0;
for (int i = 0; i < k; i++) {
long long p = (s[i] == '+' ? 1 : -1);
ans = (ans + p * qpow(a, n - i) * qpow(b, i) % MOD + MOD) % MOD;
}
long long q = qpow((b * qpow(a, MOD - 2)) % MOD, k);
if (q == 1)
ans = (ans * (n + 1) / k + MOD) % MOD;
else
ans =
(ans * (1 - qpow(q, (n + 1) / k)) % MOD * qpow(1 - q, MOD - 2) + MOD) %
MOD;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans = -1;
long long add;
void Case1(long long N, long long K, long long y, long long P, long long lo,
long long hi) {
if (lo > hi or K < 0) return;
while (hi > lo) {
long long x = (hi + lo + 1) / 2;
long long R = K - P * (N + x);
if (R >= y)
lo = x;
else
hi = x - 1;
}
long long R = K - P * (N + lo);
if (R >= y && R <= y + lo) {
ans = max(ans, lo + add);
}
}
void Case2(long long N, long long K, long long y, long long P, long long lo,
long long hi) {
if (lo > hi or K < 0) return;
while (hi > lo) {
long long x = (hi + lo + 1) / 2;
long long R = K - P * (N + x);
if (R >= y)
lo = x;
else
hi = x - 1;
}
long long R = K - P * (N + lo);
if (R >= y && R <= y + y) {
ans = max(ans, lo + add);
}
}
void Case3(long long N, long long K, long long y, long long P, long long lo,
long long hi) {
if (lo > hi or K < 0) return;
while (hi > lo) {
long long x = (hi + lo + 1) / 2;
long long R = K - P * (N + x);
if (R >= x + 2 * y - N)
lo = x;
else
hi = x - 1;
}
long long R = K - P * (N + lo);
if (R >= lo + 2 * y - N && R <= y + y) {
ans = max(ans, lo + add);
}
}
void Case4(long long N, long long K, long long y, long long P, long long lo,
long long hi) {
if (lo > hi or K < 0) return;
while (hi > lo) {
long long x = (hi + lo + 1) / 2;
long long R = K - P * (N + x);
if (R >= x + 2 * y - N)
lo = x;
else
hi = x - 1;
}
long long R = K - P * (N + lo);
if (R >= lo + 2 * y - N && R <= lo + y) {
ans = max(ans, lo + add);
}
}
void Case11(long long N, long long K, long long y, long long P, long long lo,
long long hi) {
if (lo > hi or K < 0) return;
while (hi > lo) {
long long x = (hi + lo + 1) / 2;
long long R = K - P * (N + x);
if (R >= y + 1)
lo = x;
else
hi = x - 1;
}
long long R = K - P * (N + lo);
if (R >= y + 1 && R <= y + lo) {
ans = max(ans, lo + add);
}
}
void Case22(long long N, long long K, long long y, long long P, long long lo,
long long hi) {
if (lo > hi or K < 0) return;
while (hi > lo) {
long long x = (hi + lo + 1) / 2;
long long R = K - P * (N + x);
if (R >= y + 1)
lo = x;
else
hi = x - 1;
}
long long R = K - P * (N + lo);
if (R >= y + 1 && R <= y + y) {
ans = max(ans, lo + add);
}
}
void Case33(long long N, long long K, long long y, long long P, long long lo,
long long hi) {
if (lo > hi or K < 0) return;
while (hi > lo) {
long long x = (hi + lo + 1) / 2;
long long R = K - P * (N + x);
if (R >= max(1LL, x + y - N) + y)
lo = x;
else
hi = x - 1;
}
long long R = K - P * (N + lo);
if (R >= max(1LL, lo + y - N) + y && R <= y + y) {
ans = max(ans, lo + add);
}
}
void Case44(long long N, long long K, long long y, long long P, long long lo,
long long hi) {
if (lo > hi or K < 0) return;
while (hi > lo) {
long long x = (hi + lo + 1) / 2;
long long R = K - P * (N + x);
if (R >= max(1LL, x + y - N) + y)
lo = x;
else
hi = x - 1;
}
long long R = K - P * (N + lo);
if (R >= max(1LL, lo + y - N) + y && R <= lo + y) {
ans = max(ans, lo + add);
}
}
void ints(long long &x, long long &y, long long a, long long b) {
x = max(x, a);
y = min(y, b);
}
void solve_0(long long N, long long K, long long y) {
vector<long long> divs;
for (long long d = 1; d * d <= K; d++) {
if (K % d == 0) {
divs.push_back(d);
divs.push_back(K / d);
}
}
for (auto d : divs) {
if (d >= N) {
long long x = d - N;
if (x <= N) ans = max(ans, x);
}
}
divs.clear();
for (long long d = 1; d * d <= K + 1; d++) {
if ((K + 1) % d == 0) {
divs.push_back(d);
divs.push_back((K + 1) / d);
}
}
for (auto d : divs) {
if (d >= N + 1) {
long long x = d - N;
if (x <= N) ans = max(ans, x);
}
}
cout << ans << endl;
exit(0);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long N, K, y, l, r;
cin >> N >> l >> r >> K;
if (N == 1) {
cout << 1 << endl;
return 0;
}
y = (r + N - l + 1) % N;
if (y == 0) {
solve_0(N, K, y);
return 0;
}
vector<pair<long long, long long>> Ranges;
for (long long x = 0; x <= N; x++) {
long long lo = x, hi = N;
while (hi > lo) {
long long mid = (hi + lo + 1) / 2;
if (K / (N + x) == K / (N + mid))
lo = mid;
else
hi = mid - 1;
}
Ranges.push_back({x, lo});
x = lo;
}
for (auto t : Ranges) {
long long a = t.first, b = t.second;
long long P = K / (N + a);
if (N - y >= y) {
long long lo = 0, hi = y;
ints(lo, hi, a, b);
Case1(N, K, y, P, lo, hi);
lo = y + 1, hi = N - y;
ints(lo, hi, a, b);
Case2(N, K, y, P, lo, hi);
lo = N - y + 1, hi = N;
ints(lo, hi, a, b);
Case3(N, K, y, P, lo, hi);
} else {
long long lo = 0, hi = N - y;
ints(lo, hi, a, b);
Case1(N, K, y, P, lo, hi);
lo = N - y + 1, hi = y;
ints(lo, hi, a, b);
Case4(N, K, y, P, lo, hi);
lo = y + 1, hi = N;
ints(lo, hi, a, b);
Case3(N, K, y, P, lo, hi);
}
}
Ranges.clear();
K++;
for (long long x = 0; x <= N; x++) {
long long lo = x, hi = N;
while (hi > lo) {
long long mid = (hi + lo + 1) / 2;
if (K / (N + x) == K / (N + mid))
lo = mid;
else
hi = mid - 1;
}
Ranges.push_back({x, lo});
x = lo;
}
for (auto t : Ranges) {
long long a = t.first, b = t.second;
long long P = K / (N + a);
if (N - y >= y) {
long long lo = 0, hi = y;
ints(lo, hi, a, b);
Case11(N, K, y, P, lo, hi);
lo = y + 1, hi = N - y;
ints(lo, hi, a, b);
Case22(N, K, y, P, lo, hi);
lo = N - y + 1, hi = N;
ints(lo, hi, a, b);
Case33(N, K, y, P, lo, hi);
} else {
long long lo = 0, hi = N - y;
ints(lo, hi, a, b);
Case11(N, K, y, P, lo, hi);
lo = N - y + 1, hi = y;
ints(lo, hi, a, b);
Case44(N, K, y, P, lo, hi);
lo = y + 1, hi = N;
ints(lo, hi, a, b);
Case33(N, K, y, P, lo, hi);
}
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
inline int max(int a, int b) { return a > b ? a : b; }
int main() {
long long ans = 0;
int n, m;
scanf("%d%d", &n, &m);
for (int b = 1; b <= n; b++) {
long long t = (long long)b * b;
ans += t <= m ? (t << 1) - 1 : m << 1;
}
for (int u = -n * 2; u < 0; u++) {
int min1 = max(-(n << 1) - u, m / u);
if (u & 1) min1--;
int t = -min1 >> 1;
if (t > 1) ans -= t - 1;
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
int main (){
ios::sync_with_stdio(0);cin.tie(0);
int n,m;
cin>>n>>m;
for (int i=0;i<n;i++){
for (int j=0;j<m;j++){
int a;
cin>>a;
if ((i+j)%2) cout<<"720720 ";
else cout<<720720-a*a*a*a<<" ";
}
cout<<'\n';
}
} | 7 |
#include <bits/stdc++.h>
using namespace std;
int vis[110], f[110][110], hh[110];
int use[110];
vector<int> a[110];
int q[110], top;
int n, m;
void bfs() {
while (top != 0) {
int tmp = q[--top];
for (int i = 1; i <= m; i++)
if (f[tmp][i]) {
for (int j = 0; j < a[i].size(); j++)
if (!vis[a[i][j]]) {
vis[a[i][j]] = 1;
q[top++] = a[i][j];
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
int ans = 0;
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
if (k == 0) {
ans++;
vis[i] = 1;
}
for (int j = 1; j <= k; j++) {
int x;
scanf("%d", &x);
f[i][x] = 1;
a[x].push_back(i);
}
}
int first = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
top = 0;
q[top++] = i;
vis[i] = 1;
bfs();
if (first) {
first = 0;
} else
ans++;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << 1 << " " << 1 << endl;
cout << -34688642 << endl;
cout << 1 << " " << 1 << endl;
cout << 0 << endl;
cout << 1 << " " << 1 << endl;
cout << 0 << endl;
return 0;
}
cout << 1 << " " << n - 1 << endl;
for (int i = 0; i < n - 1; i++) cout << (a[i] * (n - 1)) << " ";
cout << endl;
cout << n << " " << n << endl;
cout << -a[n - 1] << endl;
cout << 1 << " " << n << endl;
for (int i = 0; i < n - 1; i++) cout << (-(a[i] * n)) << " ";
cout << 0 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s[100010];
int mx[2000100];
int id[2000010];
int main() {
int n, pos;
cin >> n;
int max_pos = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
int k;
cin >> k;
int len = (int)s[i].length();
for (int j = 0; j < k; j++) {
scanf("%d", &pos);
if (pos > max_pos) {
max_pos = pos;
}
if (len > mx[pos]) {
mx[pos] = len;
id[pos] = i;
}
}
}
int now_max = 0;
for (int i = 1; i <= max_pos; i++) {
if (mx[i] == 0) {
cout << 'a';
} else {
for (int j = 0; j < mx[i]; j++) {
if (mx[i + j] + i + j > i + mx[i]) {
i = i + j;
j = 0;
}
cout << s[id[i]][j];
}
i = i + mx[i];
i--;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
unsigned int n, i, j, k, l, o;
scanf("%d", &n);
double **m = (double **)malloc(n * sizeof(double *));
for (i = 0; i < n; i++) {
m[i] = (double *)malloc(n * sizeof(double));
for (j = 0; j < n; j++) scanf("%lf", &(m[i][j]));
}
unsigned int t = (1 << n), s = t - 1, pri = t >> 1, cont;
double *v = (double *)malloc(t * sizeof(double)), som, pj;
v[0] = 0.0;
v[s] = 1.0;
for (k = (s - 1); k > 0; k--) {
v[k] = 0.0;
cont = 1;
for (o = pri; o > 0; o >>= 1)
if (o & k) cont++;
pj = 2.0 / (cont * (cont - 1));
for (j = 0, l = pri; l > 0; l >>= 1, j++) {
if (l & k) continue;
som = 0.0;
for (i = 0, o = pri; o > 0; o >>= 1, i++)
if (o & k) som += m[i][j];
v[k] += (som * pj * v[(k | l)]);
}
}
for (i = 0, k = pri; i < n; i++, k >>= 1) printf("%.6lf ", v[k]);
printf("\n");
for (i = 0; i < n; i++) free(m[i]);
free(m);
free(v);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, ans, last, d, x, y, a, b;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void exgcd(long long a, long long b, long long& d, long long& x, long long& y) {
if (!b) {
x = 1, y = 0, d = a;
} else {
exgcd(b, a % b, d, y, x);
y -= (a / b) * x;
}
}
void check(long long x0, long long y0) {
exgcd(a, b, d, x, y);
if ((y0 - x0) % d != 0) return;
long long tmp = abs(b / d);
x *= (y0 - x0) / d;
x = (x % tmp + tmp) % tmp;
long long xx = x0 + 2 * n * x;
if (xx < 0 || xx >= last) return;
ans = min(ans, xx);
}
int main() {
cin >> n >> m >> k;
a = 2 * n, b = -2 * m;
while (k--) {
long long xx, yy;
cin >> xx >> yy;
ans = 1e18;
last = n / gcd(n, m) * m;
check(xx, yy);
check(-xx, yy);
check(xx, -yy);
check(-xx, -yy);
if (ans == 1e18)
cout << -1 << endl;
else
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int k, n;
char s[1000006];
pair<pair<bool, bool>, bool> dfs() {
switch (s[k]) {
case '1':
return make_pair(make_pair(0, 0), 1);
case '0':
return make_pair(make_pair(1, 0), 0);
case '?':
return make_pair(make_pair(0, 1), 0);
}
k++;
pair<pair<bool, bool>, bool> f1 = dfs();
k++;
char ch = s[k];
k++;
pair<pair<bool, bool>, bool> f2 = dfs();
k++;
switch (ch) {
case '|':
return make_pair(
make_pair(f1.first.first && f2.first.first,
f1.first.first && f2.first.second ||
f1.first.second && f2.first.second ||
f1.first.second && f2.first.first),
f1.first.second && f2.first.second || f2.second || f1.second);
case '&':
return make_pair(make_pair(f1.first.first || f2.first.first ||
f1.first.second && f2.first.second,
f1.first.second && f2.first.second ||
f1.first.second && f2.second ||
f1.second && f2.first.second),
f1.second && f2.second);
case '^':
return make_pair(make_pair(f1.first.first && f2.first.first ||
f1.first.second && f2.first.second ||
f1.second && f2.second,
f1.first.first && f2.first.second ||
f1.first.second && f2.second ||
f1.first.second && f2.first.first ||
f1.second && f2.first.second),
f1.first.first && f2.second ||
f1.first.second && f2.first.second ||
f1.second && f2.first.first);
}
}
int main() {
scanf("%d", &n);
scanf("%s", s);
pair<pair<bool, bool>, bool> ans = dfs();
if (ans.first.second)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct rec {
int next, to;
} edge[100000 * 2 + 1];
int dfn[100000 + 1], low[100000 + 1], head[100000 + 1], a[100000 + 1],
b[100000 + 1], s[100000 + 1], n, m, h, cnt = 1, ans = 2147483647, tot = 0;
bool bz[100000 + 1], bz1[100000 + 1];
void add(int u, int v) {
edge[cnt].to = v, edge[cnt].next = head[u];
head[u] = cnt++;
}
void tarjan(int k) {
dfn[k] = low[k] = ++tot, s[++s[0]] = k, bz1[k] = true, bz[k] = false;
for (int i = head[k]; i; i = edge[i].next) {
if (!dfn[edge[i].to]) {
tarjan(edge[i].to);
low[k] = min(low[k], low[edge[i].to]);
} else if (bz1[edge[i].to])
low[k] = min(low[k], dfn[edge[i].to]);
}
if (dfn[k] == low[k]) {
bool bz2 = true;
int size = 0;
for (int i = s[0]; i; i = (s[i] == k ? 0 : i - 1)) {
++size;
for (int j = head[s[i]]; j; j = edge[j].next)
if (!bz1[edge[j].to]) bz2 = false;
}
if (bz2 && size < ans) {
ans = size;
for (int i = s[0]; i; i = (s[i] == k ? 0 : i - 1), size--, --s[0]) {
bz1[s[i]] = false, b[ans - size + 1] = s[i];
}
} else {
for (int i = s[0]; i; i = (s[i] == k ? 0 : i - 1), --s[0])
bz1[s[i]] = false;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if ((a[x] + 1) % h == a[y]) add(x, y);
if ((a[y] + 1) % h == a[x]) add(y, x);
}
memset(bz, true, sizeof bz);
memset(dfn, 0, sizeof dfn);
memset(low, 0, sizeof low);
s[0] = 0;
for (int i = 1; i <= n; i++) {
if (bz[i]) tarjan(i);
tot = 0;
}
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) printf("%d ", b[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, a[100], i, sum = 0;
cin >> n >> t;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
sum += 86400 - a[i];
if (sum >= t) {
cout << i + 1;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char line[100001];
vector<pair<int, int>> branches, final;
int main() {
int c, len = 0;
bool open = false;
pair<int, int> x;
while ((c = getchar()) != EOF && c != '\n') {
line[len++] = c;
if (c == '"') {
if (open) {
x.second = len - 1;
branches.push_back(x);
} else {
x.first = len - 1;
}
open = !open;
}
}
line[len] = 0;
int bindex = 0;
for (int i = 0; i < len;) {
while (bindex < branches.size() && (i > branches[bindex].second)) ++bindex;
if (bindex < branches.size()) {
if (i >= branches[bindex].first) {
putchar('<');
for (int j = branches[bindex].first + 1; j < branches[bindex].second;
++j)
putchar(line[j]);
putchar('>');
puts("");
i = branches[bindex].second + 1;
} else {
while (i < len && line[i] == ' ') ++i;
bool smth = false;
while (i < len && line[i] != '"' && line[i] != ' ') {
if (!smth) smth = true, putchar('<');
putchar(line[i++]);
}
if (smth) putchar('>'), puts("");
}
} else {
while (i < len && line[i] == ' ') ++i;
bool smth = false;
while (i < len && line[i] != '"' && line[i] != ' ') {
if (!smth) smth = true, putchar('<');
putchar(line[i++]);
}
if (smth) putchar('>'), puts("");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << '(' << p.first << ", " << p.second << ')';
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
long long l = v.size();
for (long long i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
template <typename T>
void trace(const char* name, T&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
trace(comma + 1, args...);
}
const int N = 10004;
vector<pair<int, int> > hori[N], vert[N];
struct bit {
int n;
vector<int> tree;
bit(int n) : n(n) { tree.assign(n + 1, 0); }
int query(int l, int r) { return query(r) - query(l - 1); }
int query(int r) {
int s = 0;
for (; r > 0; r -= (r & (-r))) s += tree[r];
return s;
}
void update(int i, int v) {
for (; i <= n; i += (i & (-i))) tree[i] += v;
}
};
const int D = 5001;
pair<int, int> intersection(pair<int, int> a, pair<int, int> b) {
if (b.first > a.second || a.first > b.second) {
return make_pair(-1, -1);
}
return make_pair(max(a.first, b.first), min(a.second, b.second));
}
vector<int> fin[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a += D;
b += D;
c += D;
d += D;
if (b == d) {
hori[b].push_back({min(a, c), max(a, c)});
} else {
vert[a].push_back({min(b, d), max(b, d)});
}
}
bit t(N);
auto c2 = [](long long c) -> long long { return ((c * (c - 1)) / 2); };
long long ans = 0;
for (int i = 1; i < N; i++) {
for (auto h : hori[i]) {
int l = h.first;
int r = h.second;
vector<int> pre;
for (int j = l; j <= r; j++) {
for (auto& v : vert[j]) {
if (v.first <= i && v.second > i) {
fin[v.second + 1].push_back(j);
pre.push_back(v.second + 1);
t.update(j, 1);
}
}
}
for (int j = i + 1; j < N; j++) {
for (auto& k : fin[j]) {
t.update(k, -1);
}
for (auto& h2 : hori[j]) {
auto ii = intersection(h, h2);
if (ii.first != -1) {
int c = t.query(ii.first, ii.second);
ans += c2(c);
}
}
}
for (auto& j : pre) {
fin[j].clear();
}
}
}
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
int main() {
int i, j, k, p, t, m, n, number = 0;
int temp[4];
char *ptr = (char *)malloc(50 * 50 * sizeof(char));
char **mass = (char **)malloc(50 * sizeof(char *));
for (i = 0; i < 50; i++) mass[i] = &ptr[i * 50];
scanf("%d%d", &n, &m);
for (gets(ptr), i = 0; i < n; i++) {
for (j = 0; j < m; j++) mass[i][j] = getchar();
getchar();
}
for (n--, m--, i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
for (k = 0; k < 4; temp[k] = 0, k++)
;
for (p = 0; p < 2; p++) {
for (t = 0; t < 2; t++) {
switch (mass[i + p][j + t]) {
case 'f':
temp[0]++;
break;
case 'a':
temp[1]++;
break;
case 'c':
temp[2]++;
break;
case 'e':
temp[3]++;
break;
}
}
}
for (k = 0; k < 4 && temp[k]; k++)
;
if (k == 4) number++;
}
}
printf("%d", number);
free(mass);
free(ptr);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
vector<int>::iterator v1;
int n, x, sum1 = 0, sum2 = 0;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x;
sum1 = sum1 + x;
sum2 = sum2 + i;
}
sum2 = sum2 + n;
cout << sum2 - sum1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int inf = (int)1e9;
using namespace std;
int l[100011], r[100011];
int p;
long double h[100011];
long double f[100011];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n >> p;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
h[i] = r[i] / p - (l[i] - 1) / p;
}
h[0] = h[n];
h[n + 1] = h[1];
r[n + 1] = r[1];
l[n + 1] = l[1];
long double sum = 0;
for (int i = 1; i <= n; i++) {
long double length = r[i] - l[i] + 1;
f[i] = (length - h[i]) / length;
}
f[n + 1] = f[1];
for (int i = 1; i <= n; i++) {
sum += 1.0 - (f[i] * f[i + 1]);
}
cout << fixed << setprecision(6) << sum * 2000;
return 0;
}
| 4 |
// #pragma comment(linker, "/stack:200000000")
// #pragma GCC optimize("Ofast,unroll-all-loops")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#define ll long long
#define int ll
#define ld long double
#define pb push_back
#define ff first
#define ss second
#define files(in, out) freopen(in, "r", stdin); freopen(out, "w", stdout)
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(a) a.begin(), a.end()
#define pii pair<int, int>
#define mp make_pair
using namespace std;
const int p = 31;
const int mod = 1e9 + 6;
const int max_n = 8e4 + 5;
const int log_n = 20;
const int inf = 1e9;
const long double pi = acos(-1);
const ld eps = 1e-11;
// const int len = 1600;
std::mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int sz;
struct ST {
vector<int> t;
ST() {
t.resize(4 * sz, inf);
}
void build(vector<int> &a, int v = 0, int vl = 0, int vr = sz) {
if (vr - vl == 1) {
if (vl < a.size())
t[v] = a[vl];
return;
}
int vm = (vl + vr) / 2;
build(a, 2 * v + 1, vl, vm);
build(a, 2 * v + 2, vm, vr);
t[v] = min(t[2 * v + 1], t[2 * v + 2]);
}
int get(int lq, int rq, int v = 0, int vl = 0, int vr = sz){
if (lq >= vr || vl >= rq) return inf;
if (lq <= vl && vr <= rq) return t[v];
int vm = (vl + vr) / 2;
return min(get(lq, rq, 2 * v + 1, vl, vm), get(lq, rq, 2 * v + 2, vm, vr));
}
};
void run() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) {
cin >> a[i];
}
sz = n;
ST tree;
tree.build(a);
map<int, pii> mapik;
int cur = 0;
for (int i = n - 1; i >= 0; --i) {
cur = max(cur, a[i]);
if (mapik.count(cur) == 0) mapik[cur] = {i, i};
else mapik[cur].ff = i;
}
cur = 0;
rep(i, n - 2) {
cur = max(a[i], cur);
pii mbo = mapik[cur];
mbo.ff--, mbo.ss--;
mbo.ff = max(mbo.ff, i + 1);
if (mbo.ff > mbo.ss) continue;
int l = mbo.ff;
int r = mbo.ss + 1;
while (r - l > 1) {
int mid = (l + r) / 2;
int res = tree.get(i + 1, mid + 1);
if (res >= cur) {
l = mid;
} else {
r = mid;
}
}
int res = tree.get(i + 1, l + 1);
if (res == cur) {
cout << "YES\n";
cout << i + 1 << ' ' << l - i << ' ' << n - (i + 1) - (l - i) << '\n';
return;
}
}
cout << "NO\n";
}
signed main() {
#ifndef ONLINE_JUDGE
files("input.txt", "output.txt");
#endif
// files("optimize.in", "optimize.out");
// srand(time(0));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--)
run();
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long a[100100], b[100100], ans;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + m, greater<long long>());
n = min(n, m);
for (int i = 0; i < n and a[i] < b[i]; i++) {
ans += b[i] - a[i];
}
cout << ans << endl;
;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[2000005], res[2000005];
int main() {
int n;
cin >> n;
string f, s;
vector<string> rat, womch, man, cap;
for (int i = 0; i < n; i++) {
cin >> f >> s;
if (s == "rat") rat.push_back(f);
if (s == "woman" || s == "child") womch.push_back(f);
if (s == "man") man.push_back(f);
if (s == "captain") cap.push_back(f);
}
for (int i = 0; i < rat.size(); i++) cout << rat[i] << endl;
for (int i = 0; i < womch.size(); i++) cout << womch[i] << endl;
for (int i = 0; i < man.size(); i++) cout << man[i] << endl;
for (int i = 0; i < cap.size(); i++) cout << cap[i] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int c[13];
int d[13];
int a[13];
int b[13];
int dp[1011];
int dp2[1011];
int main(int argc, char* argv[]) {
int N, M;
cin >> N >> M;
cin >> c[0] >> d[0];
for (int i = 1; i <= M; i++) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
}
memset(dp, -60, sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= M; i++) {
memcpy(dp2, dp, sizeof(dp));
for (int cnt = 1; cnt * b[i] <= a[i]; cnt++) {
int ct = cnt * c[i];
for (int t = 1001 - ct; t >= 0; t--) {
dp2[t + ct] = max(dp2[t + ct], dp[t] + d[i] * cnt);
}
}
memcpy(dp, dp2, sizeof(dp));
}
{
memcpy(dp2, dp, sizeof(dp));
for (int cnt = 1; cnt * c[0] <= 1000; cnt++) {
int ct = cnt * c[0];
for (int t = 1001 - ct; t >= 0; t--) {
dp2[t + ct] = max(dp2[t + ct], dp[t] + d[0] * cnt);
}
}
memcpy(dp, dp2, sizeof(dp));
}
int best = 0;
for (int i = 0; i <= N; i++) best = max(best, dp[i]);
cout << best;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x[100010], y[100010], cx[100010], cy[100010];
void read() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d %d", x + i, y + i);
cx[i] = x[i], cy[i] = y[i];
}
}
long long work() {
int s[2][2] = {{0, 0}, {0, 0}}, f = 0;
long long ans = 0;
sort(x + 1, x + n + 1), sort(y + 1, y + n + 1);
int m = (n + 1) >> 1, dx = x[m + 1] - x[m], dy = y[m + 1] - y[m];
if (n & 1) dx = min(dx, x[m] - x[m - 1]), dy = min(dy, y[m] - y[m - 1]);
for (int i = 1; i <= n; ++i) {
ans += abs(x[i] - x[m]) + abs(y[i] - y[m]);
s[cx[i] <= x[m]][cy[i] <= y[m]] = 1;
f |= cx[i] == x[m] && cy[i] == y[m];
}
if ((n % 2 == 0 || f) && s[0][0] && s[0][1]) ans -= min(dx, dy);
if (ans == 99910042073764)
cout << s[0][1] << " " << s[0][0] << " " << f << endl;
return ans * 2;
}
int main() {
read();
cout << work() << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MOD = 1e9 + 7;
long long power(long long a, long long n, long long m = MOD) {
if (n == 0) return 1;
long long p = power(a, n >> 1, m);
p = (p * p) % m;
if (n & 1) p = (p * a) % m;
return p;
}
vector<int> adj[N];
long long ways[N];
void calcDfs(int v, int p) {
ways[v] = 1;
bool isLeaf = 1;
for (auto it : adj[v]) {
if (it == p) continue;
isLeaf = 0;
calcDfs(it, v);
ways[v] = (ways[v] * ways[it]) % MOD;
}
if (not isLeaf) ways[v] = (ways[v] * 2) % MOD;
}
long long ans;
void solve(int v, int p, long long cnt) {
for (auto it : adj[v]) {
if (it == p) continue;
cnt = (cnt * ways[it]) % MOD;
}
cnt = (cnt * 2) % MOD;
ans = (ans + cnt) % MOD;
if (v == 1 and (int) adj[v].size() < 2) {
cnt = (cnt * power(2, MOD - 2)) % MOD;
}
for (auto it : adj[v]) {
if (it == p) continue;
solve(it, v, (cnt * power(ways[it], MOD - 2)) % MOD);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b), adj[b].push_back(a);
}
calcDfs(1, 0);
solve(1, 0, 1);
if (n == 1) ans = 1;
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> arr[N];
int n, m, cnt, mx, u, v, r1, r2;
bool vis[N];
int city[N];
void dfs(int cur) {
vis[cur] = 1;
for (int to : arr[cur]) {
if (!vis[to]) {
city[to] = cur;
dfs(to);
}
}
}
int main() {
cin >> n >> r1 >> r2;
for (int i = 1; i <= n; ++i) {
if (i == r1) continue;
cin >> u;
arr[i].push_back(u);
arr[u].push_back(i);
}
dfs(r2);
for (int i = 1; i <= n; ++i)
if (i == r2)
continue;
else
printf("%d ", city[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int q, w, l, r, k;
int main() {
cin >> l >> r >> q >> w >> k;
long long int e = max(l, q);
long long int j = min(r, w);
long long int g = j - e + 1;
if (e <= k && j >= k) {
g--;
}
if (g <= 0) {
cout << 0;
} else {
cout << g;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
struct nums {
int a1, a2;
} circle[200520];
int num[200520];
bool mark[200520];
memset(mark, 0, sizeof(mark));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> circle[i].a1;
cin >> circle[i].a2;
}
num[1] = 1;
mark[1] = 1;
for (int i = 1; i < n; i++) {
if (!mark[circle[num[i]].a1] == true) {
if (circle[num[i]].a2 == circle[circle[num[i]].a1].a1 ||
circle[num[i]].a2 == circle[circle[num[i]].a1].a2) {
num[i + 1] = circle[num[i]].a1;
mark[circle[num[i]].a1] = true;
} else {
num[i + 1] = circle[num[i]].a2;
mark[circle[num[i]].a2] = true;
}
} else {
num[i + 1] = circle[num[i]].a2;
mark[circle[num[i]].a2] = true;
}
}
for (int i = 1; i <= n; i++) cout << num[i] << ' ';
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
stack<char> st;
char s[100005];
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; ++i) {
if (st.empty() || st.top() != s[i])
st.push(s[i]);
else
st.pop();
}
if (st.empty())
puts("Yes");
else
puts("No");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> q[200050];
int vis[200050];
bool bfs(int u) {
queue<int> que;
que.push(u);
while (!que.empty()) {
int f = que.front();
que.pop();
for (int i = 0; i < q[f].size(); i++) {
int v = q[f][i];
if (vis[v] == -1) {
vis[v] = vis[f] ^ 1;
que.push(v);
} else {
if (vis[v] == vis[f]) return false;
}
}
}
return true;
}
int in[200050];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int u, v;
scanf("%d%d", &u, &v);
q[u].push_back(v);
q[v].push_back(u);
in[i * 2 - 1] = u;
in[i * 2] = v;
}
for (int i = 1; i <= n; i++) {
q[i * 2 - 1].push_back(i * 2);
q[i * 2].push_back(i * 2 - 1);
}
bool kx = true;
memset(vis, -1, sizeof(vis));
for (int i = 1; i <= 2 * n; i++) {
if (vis[i] == -1) {
vis[i] = 0;
kx = bfs(i);
if (!kx) break;
}
}
if (!kx) {
printf("-1\n");
} else {
for (int i = 1; i <= n; i++) {
printf("%d %d\n", vis[in[i * 2 - 1]] + 1, vis[in[i * 2]] + 1);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
pair<int, int> t[500007 * 4], a[500007];
int in, b[500007], f, lim;
vector<int> ans[500007];
set<int> st[500007];
pair<int, int> merge(pair<int, int> c, pair<int, int> d) {
return {min(c.first, d.first), max(c.second, d.second)};
}
void update(int nd, int tl, int tr, int pos) {
if (tl == tr) {
if (st[tl].size() == 0)
t[nd] = {100000000, -1};
else {
auto it = st[tl].begin();
t[nd].first = *it;
it = st[tl].end();
it--;
t[nd].second = *it;
}
return;
}
int tm = (tl + tr) >> 1;
int lc = nd << 1;
int rc = lc | 1;
if (pos <= tm)
update(lc, tl, tm, pos);
else
update(rc, tm + 1, tr, pos);
t[nd] = merge(t[lc], t[rc]);
}
void remove(int pos, int val) {
st[pos].erase(val);
update(1, 0, in, pos);
}
void add(int pos, int val) {
st[pos].insert(val);
update(1, 0, in, pos);
}
pair<int, int> query(int nd, int tl, int tr, int l, int r) {
if (l > r) return {100000000, -1};
if (tl >= l && tr <= r) return t[nd];
int tm = (tl + tr) >> 1;
int lc = nd << 1;
int rc = lc | 1;
if (r <= tm)
return query(lc, tl, tm, l, r);
else if (l > tm)
return query(rc, tm + 1, tr, l, r);
else
return merge(query(lc, tl, tm, l, r), query(rc, tm + 1, tr, l, r));
}
int main() {
int n, k, i, j, model_not_found, ind, frst, left_most_change;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n);
in = 0;
for (i = 0; i < n; i++) {
if (i) {
if (a[i].first != a[i - 1].first) in++;
}
b[a[i].second] = in;
}
for (j = 0; j <= 4 * n; j++) t[j] = {100000000, -1};
j = n - 1;
for (i = 1; i <= k; i++, j--) {
add(b[j], j);
}
frst = -1;
for (; ~j; j--) {
pair<int, int> p = query(1, 0, in, 0, b[j] - 1);
if (p.second == -1) {
frst = j;
}
add(b[j], j);
remove(b[j + k], j + k);
}
if (frst == -1) {
printf("YES\n");
return 0;
}
ind = -1;
for (i = n - 1; i > frst + k; i--) {
if (b[i] < b[frst]) {
if (ind == -1 || b[ind] <= b[i]) ind = i;
}
}
if (ind == -1) {
;
printf("NO\n");
return 0;
}
swap(b[frst + k], b[ind]);
for (j = 0; j <= in; j++) st[j].clear();
for (j = 0; j <= 4 * n; j++) t[j] = {100000000, -1};
j = n - 1;
for (i = 1; i <= k; i++, j--) {
add(b[j], j);
}
for (; ~j; j--) {
pair<int, int> p = query(1, 0, in, 0, b[j] - 1);
if (p.second == -1) {
;
printf("NO\n");
return 0;
}
add(b[j], j);
remove(b[j + k], j + k);
}
printf("YES\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 2005;
const long long oo = 1e100, eps = 1e-10, pi = 2 * asin(1);
template <class T>
T Min(const T &a, const T &b) {
return a < b ? a : b;
}
template <class T>
T Max(const T &a, const T &b) {
return a > b ? a : b;
}
struct point {
long long x, y;
point(long long _x = 0, long long _y = 0) : x(_x), y(_y) {}
point operator+(const point b) { return point(x + b.x, y + b.y); }
point operator-(const point b) { return point(x - b.x, y - b.y); }
long long operator*(const point b) { return x * b.x + y * b.y; }
long long operator^(const point b) { return x * b.y - b.x * y; }
point operator*(long long d) { return point(x * d, y * d); }
friend point operator*(long long d, const point x) {
return point(x.x * d, x.y * d);
}
point operator/(long long d) { return point(x / d, y / d); }
friend point operator/(long long d, const point x) {
return point(x.x / d, x.y / d);
}
point operator-() { return point(-x, -y); }
bool operator==(const point b) {
return fabs(x - b.x) < eps && fabs(y - b.y) < eps;
}
bool operator!=(const point b) { return !(*this == b); }
};
struct point3D {
long long x, y, z;
point3D(long long _x = 0, long long _y = 0, long long _z = 0)
: x(_x), y(_y), z(_z) {}
friend point3D operator+(const point3D x, const point3D b) {
return point3D(x.x + b.x, x.y + b.y, x.z + b.z);
}
friend point3D operator-(const point3D x, const point3D b) {
return point3D(x.x - b.x, x.y - b.y, x.z - b.z);
}
};
struct circle {
long long x, y, r;
circle(long long _x = 0, long long _y = 0, long long _r = 0)
: x(_x), y(_y), r(_r) {}
};
struct line {
point x, y;
line() {}
line(point _x, point _y) : x(_x), y(_y) {}
};
inline int sgn(long long x) { return x == 0 ? 0 : (x < 0 ? -1 : 1); }
inline long long dist(point x, point y) {
return sqrt((x.x - y.x) * (x.x - y.x) + (x.y - y.y) * (x.y - y.y));
}
inline long long cross(long long x1, long long y1, long long x2, long long y2) {
return x1 * y2 - x2 * y1;
}
inline long long dot(long long x1, long long y1, long long x2, long long y2) {
return x1 * x2 - y1 * y2;
}
long long (*cha)(long long, long long, long long, long long) = cross;
inline point3D cross(point3D x, point3D y) {
return point3D(x.y * y.z - y.y * x.z, x.z * y.x - y.z * x.x,
x.x * y.y - y.x * x.y);
}
inline long long dot(point3D x, point3D y) {
return x.x * y.x + x.y * y.y + x.z * y.z;
}
inline long long vlen(point3D x) {
return sqrt(x.x * x.x + x.y * x.y + x.z * x.z);
}
inline long long area(point3D a, point3D b, point3D c) {
return vlen(cross(b - a, c - a));
}
inline long long volume(point3D a, point3D b, point3D c, point3D d) {
return dot(cross(b - a, c - a), d - a);
}
inline point rotate(point x, long long angle) {
return point(x.x * cos(angle) - x.y * sin(angle),
x.y * cos(angle) + x.x * sin(angle));
}
inline int on_segment(point p1, line l) {
if (min(l.x.x, l.y.x) - eps <= p1.x && max(l.x.x, l.y.x) + eps >= p1.x &&
min(l.x.y, l.y.y) - eps <= p1.y && max(l.x.y, l.y.y) + eps >= p1.y)
return 1;
else
return 0;
}
inline int online(point p, line l) {
return sgn((p - l.x) * (l.y - l.x)) == 0 &&
sgn((p.x - l.x.x) * (p.x - l.y.x)) < 1 &&
sgn((p.y - l.x.y) * (p.y - l.y.y)) < 1;
}
inline long long angle(point o, point p1, point p2) {
long long fi, cosfi, norm;
long long sx = p1.x - o.x, sy = p1.y - o.y, ex = p2.x - o.x, ey = p2.y - o.y;
cosfi = sx * ex + sy * ey;
norm = (sx * sx + ey * ey) * (ex * ex + ey * ey);
cosfi /= sqrt(norm);
if (cosfi >= 1.0) return 0;
if (cosfi <= -1.0) return -pi;
fi = acos(cosfi);
if (cha(sx, sy, ex, ey) > 0)
return fi;
else
return -fi;
}
inline pair<point, point> cross_circle(circle O, point x) {
long long d1 = dist(point(O.x, O.y), x), d2 = sqrt(d1 * d1 - O.r * O.r),
angle = asin(O.r / d1);
point delta = point(O.x, O.y) - x, x1 = x + rotate(delta, -angle) * (d2 / d1),
x2 = x + rotate(delta, angle) * (d2 / d1);
return make_pair(x1, x2);
}
inline long long new_angle(long long angle) {
angle += 2 * pi;
return angle - floor(angle / (2.0 * pi)) * 2.0 * pi;
}
inline long long angle(point O, point x) {
long long angle = asin(x.y - O.y);
if (x.x - O.x < 0) angle = pi - angle;
return angle;
}
inline point to_point(circle O, long long angle) {
return point(O.x + O.r * cos(angle), O.y + O.r * sin(angle));
}
inline int direction(point p1, point p2, point p3) {
return sgn((p2 - p1) ^ (p3 - p1));
}
point quan;
int q[N];
double cc[N];
inline double qiu(point x) { return atan2(x.y, x.x); }
inline bool cmp(int a, int b) { return cc[a] < cc[b]; }
int n;
point a[N], b[N];
long long ans;
inline int cal(int l, int r) { return l <= r ? r - l : r + n - l - 1; }
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].x = read();
a[i].y = read();
b[i] = a[i];
q[i] = i;
}
for (int i = 1; i <= n; i++) {
quan = a[i];
for (int j = 1; j <= n; j++) {
cc[j] = qiu(a[j] - quan);
q[j] = j;
}
sort(&q[1], &q[n + 1], cmp);
for (int j = 1; j <= n; j++) b[j] = a[q[j]];
for (int j = 1; j <= n; j++)
if (b[j].x == a[i].x && b[j].y == a[i].y) {
for (int k = j - 1; k; k--) swap(b[k], b[k + 1]);
break;
}
int k = 3;
for (int j = 2; j <= n; j++) {
if (k == j) k = (k + 1 > n ? 2 : k + 1);
while (k != j) {
if (direction(quan, b[k], b[j]) < 0) {
k++;
if (k > n) k = 2;
} else
break;
}
long long t = cal(k, j);
if (t < 2 || t + 2 > n - 2) continue;
ans += 2 * (t * (t - 1) / 2) * ((n - 2 - t) * (n - 2 - t - 1) / 2);
}
}
cout << ans / 4 << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long a[2007], b[2007], sum[2007];
bool vis[24000014];
vector<long long> v;
int main() {
long long n, k, i, j, x, y;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (i = 1; i <= k; i++) {
cin >> b[i];
vis[b[i] + 12000007] = true;
}
long long temp = b[1];
long long flag = 0, cnt = 0;
long long countt = k;
for (i = 1; i <= n; i++) {
for (j = 1; j <= k; j++) {
vis[b[j] + 12000007] = true;
}
flag = 0;
countt = k;
long long now = temp - sum[i];
for (j = 1; j <= n; j++) {
long long noww = now + sum[j];
if (vis[noww + 12000007]) {
vis[noww + 12000007] = false;
countt--;
}
}
if (countt == 0) {
cnt++;
v.push_back(now);
}
}
if (v.size() == 0) {
cout << 0 << endl;
return 0;
} else {
sort(v.begin(), v.end());
cnt = 1;
for (i = 1; i < v.size(); i++) {
if (v[i] != v[i - 1]) cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int P = 10, N = 1e5 + 10;
inline int inverse(int a, int m) {
if (a <= 1) return a;
int ans = (1 - (long long int)inverse(m % a, a) * m) / a;
return ans + m;
}
int fact[N], ifact[N], pot[N][P];
int sz, p[P];
inline void primes(int n) {
for (int d = 2; d * d <= n; d++)
if (n % d == 0) {
p[sz++] = d;
while (n % d == 0) n /= d;
}
if (n > 1) p[sz++] = n;
}
int mod;
int expo[P][N];
inline int comb(int m, int n) {
int ans = (long long int)fact[m] * ifact[n] % mod * ifact[m - n] % mod;
for (register int i = 0; i < (int)(sz); ++i) {
int pp = pot[m][i] - pot[n][i] - pot[m - n][i];
if (pp) ans = (long long int)ans * expo[i][pp] % mod;
}
return ans;
}
inline int go(int n, int bal) {
long long int ans = 0;
for (register int x = 0, y = bal; x + y <= n; ++x, ++y)
ans += (long long int)comb(n, x) * comb(n - x, y) % mod;
return ans % mod;
}
int main() {
int n, l, r;
cin >> n >> mod >> l >> r;
primes(mod);
fact[0] = ifact[0] = 1;
int fn = 1;
for (register int j = 0; j < (int)(sz); ++j) expo[j][0] = 1;
for (int i = 1; i <= n; i++) {
int d = -1;
for (register int j = 0; j < (int)(sz); ++j)
if (i % p[j] == 0) {
d = j;
break;
}
if (d == -1)
fact[i] = i;
else {
fact[i] = fact[i / p[d]];
for (register int j = 0; j < (int)(sz); ++j)
pot[i][j] = pot[i / p[d]][j] + (j == d);
}
fn = (long long int)fn * fact[i] % mod;
for (register int j = 0; j < (int)(sz); ++j)
expo[j][i] = (long long int)expo[j][i - 1] * p[j] % mod;
}
ifact[n] = inverse(fn, mod);
for (register int i = n - 1; i >= 0; --i)
ifact[i] = (long long int)ifact[i + 1] * fact[i + 1] % mod;
for (register int i = 1; i <= n; ++i) {
fact[i] = (long long int)fact[i - 1] * fact[i] % mod;
for (register int j = 0; j < (int)(sz); ++j) pot[i][j] += pot[i - 1][j];
}
long long int ans = 0;
for (register int i = 0; i < (int)(2); ++i)
ans += (long long int)go(n, l + i) + mod - go(n, r + 1 + i);
cout << ans % mod << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
int n, t;
double p, dp[N][N];
signed main() {
scanf("%d %lf %d", &n, &p, &t);
dp[0][0] = 1;
for (int i = 1; i <= t; ++i) {
dp[i][0] = dp[i - 1][0] * (1 - p);
for (int j = 1; j <= n; ++j) {
if (j == n)
dp[i][j] = dp[i - 1][j - 1] * p + dp[i - 1][j];
else
dp[i][j] = dp[i - 1][j - 1] * p + dp[i - 1][j] * (1 - p);
}
}
double ans = 0;
for (int i = 0; i <= n; ++i) ans += dp[t][i] * (double)i;
printf("%.12lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace Dinic {
const int MAXN = 15000;
const int inf = 1e9;
vector<pair<int, int> > E[MAXN];
vector<int> cap[MAXN];
int dist[MAXN];
int bio[MAXN];
int sh[MAXN];
int cookie, s, t;
queue<int> Q;
int bfs() {
cookie++;
while (!Q.empty()) Q.pop();
bio[s] = cookie;
dist[s] = 0;
Q.push(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < (int)E[x].size(); ++i) {
int y = E[x][i].first;
if ((bio[y] != cookie || y == t) && cap[x][i] != 0) {
dist[y] = dist[x] + 1;
bio[y] = cookie;
if (y != t) Q.push(y);
}
}
}
return bio[t] == cookie;
}
int augment(int x, int c) {
if (x == t) return c;
for (int i = sh[x]; i < (int)E[x].size(); ++i, ++sh[x]) {
int y = E[x][i].first;
if (cap[x][i] > 0 && bio[y] == cookie &&
(y == t || dist[y] == dist[x] + 1)) {
int v = augment(y, c = min(c, cap[x][i]));
if (v > 0) {
cap[x][i] -= v, cap[y][E[x][i].second] += v;
return v;
}
}
}
return 0;
}
void addEdge(int a, int first, int cab, int cba) {
E[a].push_back(pair<int, int>(first, E[first].size()));
E[first].push_back(pair<int, int>(a, E[a].size() - 1));
cap[a].push_back(cab);
cap[first].push_back(cba);
}
int maxflow(int S, int T) {
s = S, t = T;
int ans = 0;
while (bfs()) {
int f;
memset(sh, 0, (T + 1) * 4);
while ((f = augment(s, inf))) ans += f;
}
return ans;
}
}; // namespace Dinic
const int MAXV = 1e6;
const int MAXN = 110;
int a[MAXN], first[MAXN], c[MAXN];
int l[MAXN], r[MAXN];
int v[MAXN][220];
int x[MAXN], y[MAXN], second[MAXN];
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < (n); ++i) scanf("%d %d %d", a + i, first + i, c + i);
int cnt = 0;
for (int i = 0; i < (n); ++i) {
scanf("%d %d", l + i, r + i);
l[i] += 101, r[i] += 101;
for (int j = l[i] - 1; j <= r[i]; ++j) v[i][j] = cnt++;
}
int s = cnt++, t = cnt++;
for (int i = 0; i < (m); ++i) {
scanf("%d %d %d", x + i, y + i, second + i);
--x[i], --y[i];
}
for (int i = 0; i < (m); ++i)
for (int j = l[x[i]] - 1; j <= r[x[i]]; ++j)
if (j - second[i] >= l[y[i]] - 1 && j - second[i] <= r[y[i]])
Dinic::addEdge(v[x[i]][j], v[y[i]][j - second[i]], Dinic::inf, 0);
for (int i = 0; i < (n); ++i) {
for (int j = l[i]; j <= r[i]; ++j) {
int f = j - 101;
Dinic::addEdge(v[i][j - 1], v[i][j],
MAXV - (a[i] * f * f + first[i] * f + c[i]), 0);
}
Dinic::addEdge(s, v[i][l[i] - 1], Dinic::inf, 0);
Dinic::addEdge(v[i][r[i]], t, Dinic::inf, 0);
}
int ans = n * MAXV - Dinic::maxflow(s, t);
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, a, b, p, q, z, k;
cin >> t;
while (t--) {
z = 0;
k = 0;
cin >> a >> b >> n;
p = max(a, b);
q = min(a, b);
while (k <= n) {
z++;
k = q + p;
q = p;
p = k;
}
cout << z << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int sign[maxn] = {2, 3, 5, 7, 11, 13, 17, 19,
23, 29, 31, 37, 41, 43, 47, 53};
const int INF = 0x3f3f3f3f;
const int sn = 1 << 16;
int N, num[maxn], s[maxn];
int dp[maxn][sn + 5], rec[maxn][sn + 5];
inline int getstate(int a) {
int u = 0;
for (int i = 0; i < 16; i++) {
while (a % sign[i] == 0) {
a /= sign[i];
u |= (1 << i);
}
}
return u;
}
inline void put_ans(int d, int S) {
if (d == 0) return;
int u = rec[d][S];
put_ans(d - 1, S ^ s[u]);
num[d] = u;
}
void solve() {
memset(rec, -1, sizeof(rec));
rec[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < sn; j++) {
if (rec[i][j] == -1) continue;
for (int k = 1; k < 60; k++) {
if (j & s[k]) continue;
int v = j | s[k];
if (rec[i + 1][v] == -1 ||
dp[i][j] + abs(k - num[i + 1]) < dp[i + 1][v]) {
rec[i + 1][v] = k;
dp[i + 1][v] = dp[i][j] + abs(k - num[i + 1]);
}
}
}
}
int ans = INF, id;
for (int i = 0; i < sn; i++) {
if (dp[N][i] < ans && rec[N][i] != -1) {
ans = dp[N][i];
id = i;
}
}
put_ans(N, id);
for (int i = 1; i < N; i++) printf("%d ", num[i]);
printf("%d\n", num[N]);
}
int main() {
for (int i = 1; i < 60; i++) s[i] = getstate(i);
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &num[i]);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
struct Node {
int seg[100005 << 2], add[100005 << 2], mul[100005 << 2];
inline void pushup(int rt) { seg[rt] = seg[(rt << 1)] + seg[(rt << 1 | 1)]; }
inline void pushdown(int rt, int sizel, int sizer) {
if (mul[rt]) {
add[(rt << 1)] = add[(rt << 1 | 1)] = seg[(rt << 1)] =
seg[(rt << 1 | 1)] = 0;
mul[(rt << 1)] = mul[(rt << 1 | 1)] = 1;
mul[rt] = 0;
}
seg[(rt << 1)] += sizel * add[rt];
seg[(rt << 1 | 1)] += sizer * add[rt];
add[(rt << 1)] += add[rt];
add[(rt << 1 | 1)] += add[rt];
add[rt] = 0;
}
void update(int L, int R, int C, int rt, int l, int r) {
if (L <= l && R >= r) {
seg[rt] += (r - l + 1) * C;
add[rt] += C;
return;
}
if (L > r || R < l) return;
int mid = (l + r) >> 1;
pushdown(rt, mid - l + 1, r - mid);
if (L <= mid) update(L, R, C, (rt << 1), l, mid);
if (R > mid) update(L, R, C, (rt << 1 | 1), mid + 1, r);
pushup(rt);
}
void reset(int L, int R, int rt, int l, int r) {
if (L <= l && R >= r) {
seg[rt] = 0;
mul[rt] = 1;
add[rt] = 0;
return;
}
if (L > r || R < l) return;
int mid = (l + r) >> 1;
pushdown(rt, mid - l + 1, r - mid);
if (L <= mid) reset(L, R, (rt << 1), l, mid);
if (R > mid) reset(L, R, (rt << 1 | 1), mid + 1, r);
pushup(rt);
}
int query(int L, int R, int rt, int l, int r) {
if (L <= l && R >= r) return seg[rt];
if (L > r || R < l) return 0;
int mid = (l + r) >> 1;
pushdown(rt, mid - l + 1, r - mid);
int ans = 0;
if (L <= mid) ans += query(L, R, (rt << 1), l, mid);
if (R > mid) ans += query(L, R, (rt << 1 | 1), mid + 1, r);
return ans;
}
} S[30];
int book[30];
int N, M;
inline char read() {
char ch = getchar();
while (ch > 'z' || ch < 'a') ch = getchar();
return ch;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i) S[read() - 'a' + 1].update(i, i, 1, 1, 1, N);
int L, R, K;
for (int k = 1; k <= M; ++k) {
scanf("%d%d%d", &L, &R, &K);
std::memset(book, 0, sizeof(book));
for (int i = 1; i <= 26; ++i) {
book[i] = S[i].query(L, R, 1, 1, N);
S[i].reset(L, R, 1, 1, N);
}
int sum = 0;
if (K == 1) {
for (int i = 1; i <= 26; ++i) {
S[i].update(L + sum, L + sum + book[i] - 1, 1, 1, 1, N);
sum += book[i];
}
} else {
for (int i = 26; i >= 1; --i) {
S[i].update(L + sum, L + sum + book[i] - 1, 1, 1, 1, N);
sum += book[i];
}
}
}
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= 26; ++j) {
if (S[j].query(i, i, 1, 1, N) == 1) {
putchar(j + 'a' - 1);
break;
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
string s[n];
bool b = true;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (s[i][j] == 'W') {
if ((i - 1 >= 0 && s[i - 1][j] == 'S') ||
(i + 1 < n && s[i + 1][j] == 'S') ||
(j - 1 >= 0 && s[i][j - 1] == 'S') ||
(j + 1 < m && s[i][j + 1] == 'S')) {
b = false;
break;
}
} else if (s[i][j] == '.')
s[i][j] = 'D';
}
if (b) {
cout << "Yes\n";
for (int i = 0; i < n; i++) cout << s[i] << endl;
} else
cout << "No\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int K = 1005;
const int D = 10005;
const double INF = 1e-7;
int k, q;
double p;
double dp[D][K];
int main() {
scanf("%d %d", &k, &q);
dp[0][0] = 1;
for (int i = 1; i < D; i++)
for (int j = 1; j <= k; j++)
dp[i][j] = ((dp[i - 1][j] * j) + (dp[i - 1][j - 1] * (k - j + 1))) / k;
for (int i = 1; i <= q; i++) {
scanf("%lf", &p);
int left = 0;
int right = D - 1;
while (left + 1 < right) {
int mid = (left + right) / 2;
if (dp[mid][k] * 2000 + INF >= p)
right = mid;
else
left = mid;
}
printf("%d\n", right);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
string S, T;
void solve() {
cin >> n;
cin >> S >> T;
int cnts[26], cntt[26];
for (int i = 0; i < 26; i++) cnts[i] = cntt[i] = 0;
for (int i = 0; i < n; i++) {
int x = int(S[i]) - 97, y = int(T[i]) - 97;
cnts[x]++;
cntt[y]++;
}
bool ok = false;
for (int i = 0; i < 26; i++) {
if (cnts[i] != cntt[i]) {
cout << "NO" << endl;
return;
}
if (cnts[i] > 1) ok = true;
}
if (ok) {
cout << "YES" << endl;
return;
}
int a = 0, b = 0;
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (int(S[j]) > int(S[i])) a++;
if (int(T[j]) > int(T[i])) b++;
}
}
if (a % 2 != b % 2)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6;
const long long mod = 1e9 + 7;
const long long inf = 1e9;
long long a[610][610], f[2][610][610];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i <= 600; i++)
for (int j = 0; j <= 600; j++) {
a[i][j] = -inf;
f[0][i][j] = -inf;
f[1][i][j] = -inf;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> a[i][j];
f[0][1][1] = a[1][1];
for (int k = 3; k <= n + n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int x = k % 2, y = 1 - x;
if (i >= k || j >= k) continue;
if (k - i > n || k - j > n) {
f[x][i][j] = -inf;
continue;
}
long long w = -inf;
for (int dx = -1; dx <= 0; dx++)
for (int dy = -1; dy <= 0; dy++) w = max(w, f[y][i + dx][j + dy]);
f[x][i][j] = w;
if (i != j)
f[x][i][j] += a[i][k - i] + a[j][k - j];
else
f[x][i][j] += a[i][k - i];
}
}
}
cout << f[0][n][n];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, dx, dy, t;
long long g[11], f[11], c[11][11], b[11][11], a[11][11];
void mul2() {
memset(g, 0, sizeof g);
for (int i = 0; i <= 5; ++i)
for (int k = 0; k <= 5; ++k) (g[i] += c[i][k] * f[k]) %= n;
memcpy(f, g, sizeof f);
}
void mul(long long c[][11], long long a[][11], long long b[][11]) {
for (int i = 0; i <= 5; ++i)
for (int j = 0; j <= 5; ++j) {
c[i][j] = 0;
for (int k = 0; k <= 5; ++k) (c[i][j] += a[i][k] * b[k][j]) %= n;
}
}
int main() {
cin >> n >> x >> y >> dx >> dy >> t;
f[0] = x - 1;
f[1] = y - 1;
f[2] = dx;
f[3] = dy;
f[4] = 0;
f[5] = 1;
a[0][0] = 2;
a[0][1] = a[0][2] = a[0][4] = 1;
a[0][5] = 2;
a[1][1] = 2;
a[1][0] = a[1][3] = a[1][4] = 1;
a[1][5] = 2;
a[2][0] = a[2][1] = a[2][2] = a[2][4] = 1;
a[2][5] = 2;
a[3][0] = a[3][1] = a[3][3] = a[3][4] = 1;
a[3][5] = 2;
a[4][4] = a[4][5] = 1;
a[5][5] = 1;
for (int i = 0; i <= 5; ++i) c[i][i] = 1;
for (int i = 0; i <= 62; ++i) {
if ((t >> i) & 1) {
mul(b, c, a);
memcpy(c, b, sizeof c);
}
mul(b, a, a);
memcpy(a, b, sizeof a);
}
mul2();
if (f[0] < 0) f[0] += n;
if (f[1] < 0) f[1] += n;
printf("%I64d %I64d\n", f[0] + 1, f[1] + 1);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int n, k, dp[1000][2001];
char s[1001];
int f(int x, int y) {
if (x >= n) return (abs(y - 1000) == k);
if (abs(y - 1000) >= k) return 0;
if (dp[x][y] != -1) return dp[x][y];
int ret = 0;
if (s[x] == 'W')
ret = f(x + 1, y + 1);
else if (s[x] == 'L')
ret = f(x + 1, y - 1);
else if (s[x] == 'D')
ret = f(x + 1, y);
else {
ret = max(ret, f(x + 1, y + 1));
ret = max(ret, f(x + 1, y - 1));
ret = max(ret, f(x + 1, y));
}
return dp[x][y] = ret;
}
void go(int x, int y) {
if (x >= n) {
puts("");
return;
}
if (s[x] == 'W') {
printf("W");
go(x + 1, y + 1);
} else if (s[x] == 'L') {
printf("L");
go(x + 1, y - 1);
} else if (s[x] == 'D') {
printf("D");
go(x + 1, y);
} else {
if (f(x + 1, y + 1)) {
printf("W");
go(x + 1, y + 1);
} else if (f(x + 1, y - 1)) {
printf("L");
go(x + 1, y - 1);
} else {
printf("D");
go(x + 1, y);
}
}
}
int main() {
scanf("%d %d%*c", &n, &k);
gets(s);
memset((dp), -1, sizeof(dp));
if (!f(0, 1000)) return 0 * puts("NO");
go(0, 1000);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
vector<int> S;
vector<pii> adj[1009];
vector<tiii> ans;
int d[1009], rt, L[1009];
int go(int x, int p, int c) {
if (x == p)
return go(adj[x][0].first, x, adj[x][0].second);
else if (d[x] == 1) {
L[p] = L[x] = x;
ans.push_back((tiii){x, S[0], -c});
return -c;
} else {
int s = c, lc = -1, rc = -1;
for (auto& it : adj[x]) {
if (it.first != p) {
s += go(it.first, x, it.second);
if (lc == -1)
lc = it.first;
else if (rc == -1)
rc = it.first;
}
}
L[p] = L[x];
ans.push_back((tiii){L[lc], S[0], -s / 2});
ans.push_back((tiii){L[rc], S[0], -s / 2});
ans.push_back((tiii){L[lc], L[rc], s / 2});
return -c;
}
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N - 1; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
adj[u].push_back({v, c});
adj[v].push_back({u, c});
++d[u];
++d[v];
}
if (N == 2) {
puts("YES\n1");
printf("1 2 %d", adj[1][0].second);
return 0;
}
for (int i = 1; i <= N; i++) {
if (d[i] == 2) return !printf("NO");
if (d[i] == 1) S.push_back(i);
}
go(S[0], S[0], 0);
puts("YES");
printf("%d\n", ans.size());
for (auto& it : ans) {
int u, v, c;
tie(u, v, c) = it;
printf("%d %d %d\n", u, v, -c);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<int> g[14];
vector<int> submasks(int mask) {
vector<int> subs;
for (int x = mask; x; x = (x - 1) & mask) subs.push_back(x);
return subs;
}
int dp[1 << 14], pd[14][14][1 << 14];
int id[14][14];
int nxt[14][14][1 << 14];
int go(int u, int w, int m) {
int& r = pd[w][u][m];
if (r != -1) return r;
r = 0x3f3f3f3f;
if (m == 0 && u == w) return r = 0;
int f = r;
for (int v : g[u]) {
int alt = 1 + go(v, w, m & (((1 << 14) - 1) ^ (1 << v)));
if (alt < f) {
f = alt;
nxt[w][u][m] = v;
}
}
return r = f;
}
vector<pair<int, int>> ans;
void build(int u, int w, int m) {
int v = nxt[w][u][m];
if (v == -1) return;
ans.emplace_back(u + 1, v + 1);
build(v, w, m & (((1 << 14) - 1) ^ (1 << v)));
}
int bits[14], sz;
inline void get_bits(int x) {
sz = 0;
while (x) {
int q = x & (-x);
bits[sz++] = __builtin_ctz(q);
x ^= q;
}
}
int bs[1 << 14], bi[1 << 14], bj[1 << 14];
int main() {
memset(dp, 0x3f, sizeof dp);
memset(pd, -1, sizeof pd);
memset(nxt, -1, sizeof nxt);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<pair<int, int>> ed;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
id[u][v] = id[v][u] = ed.size();
ed.emplace_back(u, v);
}
memset(bs, -1, sizeof bs);
for (int m = 1; m < (1 << n); m++) {
if (__builtin_popcount(m) == 1) {
dp[m] = 0;
continue;
}
for (int s : submasks(m)) {
int mts = m ^ s;
get_bits(s);
for (int i = 0; i < sz; i++) {
for (int j = i; j < sz; j++) {
int add = go(bits[i], bits[j], mts);
if (add == 2 && i == j) continue;
int alt = dp[s] + add;
if (alt < dp[m]) {
dp[m] = alt;
bs[m] = s;
bi[m] = i;
bj[m] = j;
}
}
}
}
}
int cur = (1 << n) - 1;
while (bs[cur] != -1) {
int s = bs[cur];
int i = bi[cur];
int j = bj[cur];
get_bits(s);
build(bits[i], bits[j], cur ^ s);
cur = s;
}
cout << dp[(1 << n) - 1] << "\n";
for (auto& ed : ans) {
int u, v;
tie(u, v) = ed;
cout << u << " " << v << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long test, n, a[100001], k;
bool check(string s) {
int cnt0 = 0, cnt1 = 0, cnt = 0;
for (int i = 0; i < k; i++) {
int ok1 = 0, ok0 = 0;
for (int j = i; j < n; j += k) {
if (s[j] == '1')
ok1 = 1;
else if (s[j] == '0')
ok0 = 1;
if (ok1 && ok0) return false;
}
if (ok1)
cnt1++;
else if (ok0)
cnt0++;
else
cnt++;
}
if ((cnt - abs(cnt1 - cnt0)) % 2 != 0 || (cnt - abs(cnt1 - cnt0)) < 0)
return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> test;
while (test--) {
cin >> n >> k;
string s;
cin >> s;
if (check(s))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned int n, k;
cin >> n >> k;
vector<int> res;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
unsigned int temp;
bool f = 0;
while (t--) {
cin >> temp;
if (temp < k && f == 0) {
res.push_back(i + 1);
f = 1;
}
}
}
cout << res.size() << endl;
for (auto i : res) cout << i << " ";
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
int n = a.length();
for (int i = 0; i < n; i++) {
int j = i;
while (a[j] == a[j + 1]) j++;
for (int r = i + 1; r <= j; r += 2)
if (a[j + 1] != 'a' && a[r] != 'a')
a[r] = 'a';
else if (a[j + 1] != 'b' && a[r] != 'b')
a[r] = 'b';
else
a[r] = 'c';
}
cout << a;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[1000000];
map<int, int> mp;
priority_queue<pair<int, int> > pq;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mp[arr[i]]++;
}
for (auto x : mp) {
for (int j = 1; j <= x.second; j++) {
pq.push(pair<int, int>(x.second / j, x.first));
}
}
for (int i = 0; i < k; i++) {
pair<int, int> u = pq.top();
pq.pop();
cout << u.second << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
int count, sum;
int n, m, p, t;
vector<int> v;
int maxi, mini;
int tc, ora, orb;
string s, r;
int lens, lenr;
cin >> n;
int a[n], b[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
cin >> b[i];
}
maxi = INT_MIN;
for (i = 0; i < n; i++) {
ora = a[i];
orb = b[i];
maxi = max(maxi, ora + orb);
for (j = i + 1; j < n; j++) {
ora |= a[j];
orb |= b[j];
maxi = max(maxi, ora + orb);
}
}
cout << maxi << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int dp[500][100005];
int a[1000010];
void precompute(int n) {
for (int k = 1; k <= 350; k++) {
for (int p = n; p >= 1; p--) {
if (p + a[p] + k > n) {
dp[k][p] = 1;
} else {
dp[k][p] = 1 + dp[k][p + a[p] + k];
}
}
}
}
int main() {
int n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
precompute(n);
int q;
cin >> q;
while (q--) {
int p, k;
cin >> p >> k;
if (k <= 350) {
cout << dp[k][p] << endl;
} else {
int ans = 0;
while (p <= n) {
p += (a[p] + k);
ans++;
}
cout << ans << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long dp[4001], m = 1e9 + 7;
long long c[4001][4001], efraz[4001];
void anser() {
for (int i = 0; i < 4001; i++) c[i][0] = 1;
for (int i = 1; i < 4001; i++) {
for (int j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % m;
}
}
dp[1] = 1;
dp[0] = 0;
efraz[1] = 2;
efraz[0] = 1;
for (int i = 2; i < 4001; i++) {
efraz[i] += (1ll * 2 * c[i - 1][0] * efraz[i - 1]) % m;
efraz[i] %= m;
for (int j = 1; j < i; j++) {
efraz[i] += (1ll * c[i - 1][j] * efraz[i - 1 - j]) % m;
efraz[i] %= m;
}
}
for (int i = 2; i < 4001; i++) {
dp[i] += efraz[i - 1];
dp[i] %= m;
for (int j = 0; j < i; j++) {
dp[i] += (1ll * c[i - 1][j] * dp[i - 1 - j]) % m;
dp[i] %= m;
}
}
}
long long ans() {
anser();
int n;
cin >> n;
return dp[n] % m;
}
int main() {
cout << ans();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1.12e5;
const int LEN = 6.4 * N;
int len;
int c[N], sz[N];
int s[LEN], sa[LEN], *rk, ht[LEN], v[2][LEN], ct[LEN];
long long co[LEN];
void build_sa(int n, int m) {
int *x = v[0], *y = v[1];
fill_n(ct, m, 0);
for (int i = (0); i != (n); ++i) ++ct[x[i] = s[i]];
for (int i = (1); i != (m); ++i) ct[i] += ct[i - 1];
for (int i = (n - 1); i != (-1); --i) sa[--ct[x[i]]] = i;
for (int k = 1; k < n; k <<= 1) {
int p = 0;
for (int i = (n - k); i != (n); ++i) y[p++] = i;
for (int i = (0); i != (n); ++i)
if (sa[i] >= k) y[p++] = sa[i] - k;
fill_n(ct, m, 0);
for (int i = (0); i != (n); ++i) ++ct[x[y[i]]];
for (int i = (1); i != (n); ++i) ct[i] += ct[i - 1];
for (int i = (n - 1); i != (-1); --i) sa[--ct[x[y[i]]]] = y[i];
swap(x, y);
x[sa[0]] = 0;
p = 1;
for (int i = (1); i != (n); ++i)
x[sa[i]] = y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k]
? p - 1
: p++;
if ((m = p) == n) {
rk = x;
break;
}
}
int h = 0;
ht[0] = 0;
for (int i = (0); i != (n); ++i) {
if (!rk[i]) {
h = 0;
continue;
}
while (s[i + h] == s[sa[rk[i] - 1] + h]) ++h;
ht[rk[i]] = h;
if (h) --h;
}
}
int ls[LEN], rs[LEN];
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
typedef int (*func)(int, int);
struct BIT {
func f;
int t[LEN], v;
void init(func _f, int _v) {
f = _f;
v = _v;
fill_n(t, len + 1, v);
}
void add(int i, int x) {
for (; i <= len; i += i & -i) t[i] = f(t[i], x);
}
int qry(int i) {
int ret = v;
for (; i; i ^= i & -i) ret = f(ret, t[i]);
return ret;
}
} bit;
int main() {
int n;
scanf("%d ", &n);
len = 0;
for (int i = (0); i != (n); ++i) {
int ch;
int la = len;
while ((ch = getchar()) != '\n') s[len++] = n + ch - 'a';
sz[i] = len - la;
s[len++] = i;
}
long long ans = 0;
for (int i = (0); i != (n); ++i) scanf("%d", c + i);
build_sa(len, n + 26);
int la = 0;
for (int i = (0); i != (n); ++i) {
if (ht[rk[la]] != sz[i] && ht[rk[la] + 1] != sz[i])
ans = max(ans, sz[i] * 1LL * c[i]);
la += sz[i] + 1;
}
int idx = n - 1;
for (int i = (len - 1); i != (-1); --i) co[rk[i]] = c[idx = min(idx, s[i])];
for (int i = (1); i != (len); ++i) co[i] += co[i - 1];
bit.init(max, -1);
for (int i = (0); i != (len); ++i) {
ls[i] = bit.qry(ht[i]);
bit.add(ht[i] + 1, i);
}
bit.init(min, len);
for (int i = (len - 1); i != (-1); --i) {
rs[i] = bit.qry(ht[i]);
bit.add(ht[i] + 1, i);
}
for (int i = (0); i != (len); ++i)
if (ht[i]) ans = max(ans, ht[i] * (co[rs[i] - 1] - co[ls[i] - 1]));
printf("%lld\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long int logy(long long int x, long long int y) {
return ceil((long double)(log(x) / log(y)));
}
long long int powe(long long int a, long long int b) {
long long int re = 1;
while (b) {
if (b & 1) re = (re * a) % 1000000007;
a = (a * a) % 1000000007;
b = b >> 1;
}
return re % 1000000007;
}
bool flag = 0, flag1 = 0, flag2 = 0;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int x, k;
cin >> x >> k;
if (x == 0) {
cout << 0;
return 0;
}
long long int ans = powe(2, k);
ans = (ans * ((2 * x) % 1000000007 - 1) + 1 + 1000000007) % 1000000007;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long int tab[5006];
long long int dp[5006][5006 >> 1];
long long int pref[5006][5006 >> 1];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tab[i];
}
tab[0] = tab[n + 1] = -(1e18);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= ((n + 1) >> 1); j++) {
dp[i][j] = pref[i][j] = 1e18;
}
}
for (int j = 1; j <= ((n + 1) >> 1); j++) {
for (int i = ((j - 1) << 1) + 1; i <= n; i++) {
if (j == 1) {
dp[i][j] = max((long long int)0, tab[i - 1] - tab[i] + 1) +
max((long long int)0, tab[i + 1] - tab[i] + 1);
} else {
dp[i][j] =
min(dp[i][j], dp[i - 2][j - 1] +
max((long long int)0, tab[i + 1] - tab[i] + 1) +
max((long long int)0, tab[i - 2] - tab[i]));
dp[i][j] =
min(dp[i][j], pref[i - 2][j - 1] +
max((long long int)0, tab[i + 1] - tab[i] + 1) +
max((long long int)0, tab[i - 1] - tab[i] + 1));
}
pref[i][j] = min(pref[i - 1][j], dp[i][j]);
}
}
for (int j = 1; j <= ((n + 1) >> 1); j++) {
long long int wynik = 1e18;
for (int i = 1; i <= n; i++) {
wynik = min(wynik, dp[i][j]);
}
printf("%lld ", wynik);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
struct MinDeque {
const int INF = 1e9;
deque<pair<int, int>> d;
void add(int x, int index) {
while (!d.empty() && d.back().first > x) {
d.pop_back();
}
d.push_back({x, index});
}
void removeIfNeeded(int index) {
if (!d.empty() && d.front().second == index) {
d.pop_front();
}
}
int getMin() { return d.empty() ? INF : d.front().first; }
};
void add(int &x, int y) {
x += y;
if (x >= MOD) {
x -= MOD;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, l;
cin >> n >> k >> l;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != -1) {
--a[i];
}
}
vector<int> dp1(n);
vector<vector<int>> dp2(n, vector<int>(k));
for (int i = 0; i < k; ++i) {
if (a[0] != -1 && a[0] != i) {
continue;
}
dp2[0][i] = (l == 1) ? 0 : 1;
add(dp1[0], dp2[0][i]);
}
MinDeque minDeque, maxDeque;
if (a[0] != -1) {
minDeque.add(a[0], 0);
maxDeque.add(-a[0], 0);
}
for (int i = 1; i < n; ++i) {
minDeque.removeIfNeeded(i - l);
maxDeque.removeIfNeeded(i - l);
for (int j = 0; j < k; ++j) {
if (a[i] != -1 && a[i] != j) {
continue;
}
dp2[i][j] = dp1[i - 1];
if (minDeque.getMin() >= j && j >= -maxDeque.getMin()) {
int sub = 0;
if (i - l == -1) {
sub = 1;
} else if (i >= l) {
sub = dp1[i - l];
add(sub, MOD - dp2[i - l][j]);
}
add(dp2[i][j], MOD - sub);
}
add(dp1[i], dp2[i][j]);
}
if (a[i] != -1) {
minDeque.add(a[i], i);
maxDeque.add(-a[i], i);
}
}
cout << dp1[n - 1] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 7;
int cnt, st[N], ft[N], f[N], ps[N];
vector<int> g[N];
void dfs(int x) {
st[x] = cnt++;
for (auto i : g[x]) dfs(i);
ft[x] = cnt;
}
bool is(int x, int y) { return (st[x] <= st[y] && ft[y] <= ft[x]); }
int32_t main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int t = 0;
g[0].push_back(1);
for (int i = 1; i < n; i++) {
while (t && s[t] != s[i]) t = f[t];
t += (s[t] == s[i]);
f[i + 1] = t;
g[t].push_back(i + 1);
}
dfs(0);
for (int len = 1; len * k <= n; len++) {
if (is(len * (k - 1), len * k)) {
int s = 0, e = min(len, n - k * len) + 1;
while (e - s > 1) {
int mid = (s + e) / 2;
if (is(mid, k * len + mid))
s = mid;
else
e = mid;
}
ps[len * k]++;
ps[len * k + e]--;
}
}
long long x = 0;
for (int i = 1; i <= n; i++) {
x += ps[i];
cout << !!x;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int big = 1e9 + 7;
struct node {
int x, y;
int order;
friend int operator<(node a, node b) {
if (a.x == b.x) return a.y > b.y;
return a.x < b.x;
}
};
struct tnode {
int l, r;
int m;
};
const int maxn = 300007;
node arr[maxn];
tnode t[maxn * 4];
int build(int l, int r, int root) {
t[root] = {l, r, big};
if (l > r) return big;
if (l == r) return t[root].m = arr[l].y;
int m = (l + r) / 2;
return t[root].m = min(build(l, m, root * 2), build(m + 1, r, root * 2 + 1));
}
int query(int l, int r, int root) {
if (l > r) return big;
int L = t[root].l, R = t[root].r;
if (l <= L && R <= r) return t[root].m;
int m = (L + R) / 2;
if (l >= m + 1)
return query(l, r, root * 2 + 1);
else if (m >= r)
return query(l, r, root * 2);
return min(query(l, m, root * 2), query(m + 1, r, root * 2 + 1));
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &arr[i].x, &arr[i].y);
arr[i].order = i + 1;
}
sort(arr, arr + n);
build(0, n - 1, 1);
int flag = 0;
int m = 1e9 + 7;
for (int i = 0; i < n; i++) {
m = arr[i].y;
int tem = query(i + 1, n - 1, 1);
if (tem <= m) {
flag = 1;
for (int j = i + 1; j < n; j++) {
if (arr[j].y == tem) {
cout << arr[j].order << " " << arr[i].order << endl;
break;
}
}
break;
}
}
if (flag == 0) cout << "-1 -1\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
int n, m;
int first[maxn], sign;
int vis[maxn];
int a[maxn][2];
struct node {
int to, w, next;
} edge[maxn << 1];
void init() {
for (int i = 0; i <= n; i++) first[i] = -1;
sign = 0;
}
void add_edge(int u, int v, int w) {
edge[sign].to = v;
edge[sign].w = w;
edge[sign].next = first[u];
first[u] = sign++;
}
bool flag1 = 0;
void dfs(int x, int flag) {
vis[x] = flag;
for (int i = first[x]; ~i; i = edge[i].next) {
int to = edge[i].to;
if (vis[to] == vis[x]) {
flag1 = 1;
return;
}
if (vis[to] == -1) {
dfs(to, flag ^ 1);
}
}
return;
}
int main() {
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v, 1);
add_edge(v, u, 1);
a[i][0] = u;
a[i][1] = v;
}
memset(vis, -1, sizeof(vis));
dfs(1, 1);
if (flag1)
puts("NO");
else {
puts("YES");
for (int i = 1; i <= m; i++) {
if (vis[a[i][0]] == 1)
printf("0");
else
printf("1");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct sb {
int a, id;
} s[1050];
bool cmp(sb x, sb y) { return x.a < y.a; }
int i, j, k, n, m, a[1050][1050], x[1050][1050], y[1050][1050], mxx[1050],
mxy[1050], res;
int main() {
s[0].a = -1;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
s[j].a = a[i][j];
s[j].id = j;
}
sort(s + 1, s + m + 1, cmp);
for (j = 1, k = 0; j <= m; j++) {
if (s[j].a > s[j - 1].a) {
k++;
}
x[i][s[j].id] = k;
}
mxx[i] = k;
}
for (j = 1; j <= m; j++) {
for (i = 1; i <= n; i++) {
s[i].a = a[i][j];
s[i].id = i;
}
sort(s + 1, s + n + 1, cmp);
for (i = 1, k = 0; i <= n; i++) {
if (s[i].a > s[i - 1].a) {
k++;
}
y[s[i].id][j] = k;
}
mxy[j] = k;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
res = max(mxx[i], mxy[j]);
if (x[i][j] > y[i][j]) {
res = max(res, x[i][j] + (mxy[j] - y[i][j]));
} else {
res = max(res, y[i][j] + (mxx[i] - x[i][j]));
}
printf("%d ", res);
}
puts("");
}
}
| 4 |
#include <bits/stdc++.h>
int MOD = int(1e9) + 7;
inline int add(int a, int b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline void inc(int &a, int b) { a = add(a, b); }
inline int sub(int a, int b) { return (a - b < 0) ? (a - b + MOD) : (a - b); }
inline void dec(int &a, int b) { a = sub(a, b); }
inline int mul(int a, int b) { return (a * 1ll * b) % MOD; }
using namespace std;
long long f(long long l) { return (l + 3) * (l + 2) * (l + 1) / 6; }
long long count_g(int a, int b, int c, int l) {
long long ans = 0;
for (int i = 0; i <= l; i++) {
long long lim = min(a + i - b - c, l - i);
if (lim >= 0) {
ans += (lim + 1) * (lim + 2) / 2;
}
}
return ans;
}
int main() {
int a, b, c, l;
cin >> a >> b >> c >> l;
long long ans = f(l);
ans -= count_g(a, b, c, l);
ans -= count_g(b, a, c, l);
ans -= count_g(c, a, b, l);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 10;
const long long INF = 1e15 + 7;
const int MOD = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1);
int T, cases, n, m;
long long Map[500][500];
int main() {
ios::sync_with_stdio(false);
;
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> Map[i][j];
cin >> m;
while (m--) {
long long u, v, w, ans = 0;
cin >> u >> v >> w;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
ans += (Map[i][j] =
min(Map[i][j],
min(Map[i][u] + Map[v][j], Map[i][v] + Map[u][j]) + w));
cout << ans / 2 << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long mod = 1000000007;
long long sols = 0, ti = 0;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == 'b')
ti++;
else {
sols += ti;
ti *= 2;
sols %= mod;
ti %= mod;
}
}
cout << sols << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c;
long long d[100009];
long long dd[100009];
long long p[100009];
long long e[100009][3];
long long f[100009][3];
int main() {
scanf("%I64d %I64d %I64d", &a, &b, &c);
for (int i = 1; i <= a; i++) scanf("%I64d", &d[i]);
for (int i = 1; i <= b; i++)
scanf("%I64d %I64d %I64d", &e[i][0], &e[i][1], &e[i][2]);
for (int i = 1; i <= c; i++) {
scanf("%I64d %I64d", &f[i][0], &f[i][1]);
p[f[i][0]]++;
p[f[i][1] + 1]--;
}
for (int i = 1; i <= b; i++) p[i] += p[i - 1];
for (int i = 1; i <= b; i++) {
dd[e[i][0]] += e[i][2] * p[i];
dd[e[i][1] + 1] -= e[i][2] * p[i];
}
for (int i = 1; i <= a; i++) dd[i] += dd[i - 1];
for (int i = 1; i <= a; i++) printf("%I64d ", dd[i] + d[i]);
getchar();
getchar();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int calc(int a, int b, int k) {
if (a == 1)
return 1;
else {
if (a % 2 == 0 && (b > (1 << (k - 1))))
return -1 * calc((a + 1) / 2, b - (1 << (k - 1)), k - 1);
if (b > (1 << (k - 1))) return calc((a + 1) / 2, b - (1 << (k - 1)), k - 1);
return calc((a + 1) / 2, b, k - 1);
}
}
int main() {
int i, j;
while (scanf("%d", &n) != EOF) {
int k = (1 << n);
for (i = 1; i <= k; i++) {
for (j = 1; j <= k; j++)
if (calc(i, j, n) == -1)
printf("*");
else
printf("+");
puts("");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, x[505][505], tot;
int main() {
scanf("%d", &n);
if (n <= 2) return puts("-1"), 0;
for (int i = 4; i <= n; i++) {
if (i & 1) {
for (int j = 1; j <= i; j++) x[j][i] = ++tot;
for (int j = i - 1; j >= 1; j--) x[i][j] = ++tot;
} else {
for (int j = 1; j <= i; j++) x[i][j] = ++tot;
for (int j = i - 1; j >= 1; j--) x[j][i] = ++tot;
}
}
x[1][1] = 1;
x[1][2] = 7;
x[1][3] = 9;
x[2][1] = 3;
x[2][2] = 2;
x[2][3] = 5;
x[3][1] = 4;
x[3][2] = 8;
x[3][3] = 6;
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) x[i][j] += tot;
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1; j <= n; j++) printf("%d ", x[i][j]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 123;
const int INF = 1e9 + 123;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
int n, k, a[N], ans, mx, cnt[N];
bool u[N];
int main() {
ios_base ::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
++cnt[a[i]];
mx = max(mx, cnt[a[i]]);
}
if (mx > k) {
int x = k;
while (k < mx) {
k += x;
}
mx = k;
} else
mx = k;
for (int i = 1; i <= n; ++i) {
if (!u[a[i]]) {
u[a[i]] = 1;
ans += (mx - cnt[a[i]]);
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long ans = 0;
char last = ' ', ch = getchar();
while (ch < '0' || ch > '9') last = ch, ch = getchar();
while (ch >= '0' && ch <= '9') ans = ans * 10 + ch - '0', ch = getchar();
if (last == '-') ans = -ans;
return ans;
}
const int N = 2e5 + 5;
int n;
long long k, sum, tmp, suf[N], a[N], c, ans;
long long accCeil(long long a, long long b) {
long long res = a / b;
if (res * b < a) res++;
return res;
}
int main() {
int T = read();
while (T--) {
n = read(), k = read();
sum = 0;
for (int i = 1; i <= n; ++i) {
a[i] = read();
sum += a[i];
}
if (sum <= k) {
printf("0\n");
continue;
}
if (n == 1) {
printf("%lld\n", sum - k);
continue;
}
sort(a + 1, a + n + 1);
suf[n + 1] = 0;
ans = 1e18;
for (int i = n; i > 1; --i) {
suf[i] = suf[i + 1] + a[i];
tmp = sum - k - suf[i] + (n - i + 1) * a[1];
c = max(accCeil(tmp, n - i + 2), 0ll);
ans = min(ans, n - i + 1 + c);
}
printf("%lld\n", min(ans, sum - k));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 3;
int n, m, a, b, i, nivmax, jman[nmax], haida[nmax], fol[nmax];
vector<int> t2[nmax], t1[nmax], haicaca[nmax];
void usurelu(int nod, int niv);
string p1 = "Yes";
string p2 = "No";
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i < n; ++i) {
cin >> a >> b;
t1[a].push_back(b);
t1[b].push_back(a);
jman[a] += 1;
jman[b] += 1;
haida[a] += 1;
haida[b] += 1;
}
for (int i = 1; i <= n; ++i)
if (haida[i] == 1) t2[1].push_back(i);
for (int i = 1; i <= m; ++i) {
if (!t2[i].size()) {
cout << p2;
return 0;
}
for (auto it : t2[i]) {
for (auto nanu : t1[it]) {
haida[nanu] -= 1;
if (haida[nanu] == 1) t2[i + 1].push_back(nanu);
}
}
}
if (t2[m + 1].size() != 1) {
cout << p2;
return 0;
}
usurelu(t2[m + 1][0], 1);
for (int i = 2; i < nivmax; ++i) {
for (auto it : haicaca[i]) {
if (jman[it] < 4) {
cout << p2;
return 0;
}
}
}
if (jman[haicaca[1][0]] < 3)
cout << p2;
else
cout << p1;
return 0;
}
void usurelu(int nod, int niv) {
fol[nod] = 1;
haicaca[niv].push_back(nod);
nivmax = max(nivmax, niv);
for (auto it : t1[nod])
if (!fol[it]) usurelu(it, niv + 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int ans = 0, c[N];
vector<int> g[N];
bool dfs(int p, int f, int d) {
bool t = false, b = false;
for (int x : g[p]) {
if (x != f) {
t |= dfs(x, p, d + 1);
b |= c[x];
}
}
if (t && d >= 2) {
ans++;
c[p] = 1;
return 0;
}
return !b;
}
int main() {
int n, a, b;
cin >> n;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
dfs(1, 0, 0);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
inline int get(int l, int r) {
int res = r - l - 2;
if (res < 0) res = 0;
return res;
}
char s[N];
char t[5];
int main() {
int n, qq;
scanf("%d %d", &n, &qq);
scanf("%s", s + 1);
set<int> ss = {0, n + 1};
int ans = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (s[i] == '.') {
++cnt;
} else {
s[i] = 'a';
ans += max(0, cnt - 1);
cnt = 0;
ss.insert(i);
}
}
ans += max(0, cnt - 1);
while (qq--) {
int pos;
scanf("%d %s", &pos, t);
if (t[0] != '.') {
t[0] = 'a';
}
if (t[0] != s[pos]) {
int lo = *(--ss.lower_bound(pos));
int hi = *(ss.upper_bound(pos));
if (t[0] == 'a') {
ans -= get(lo, hi);
ans += get(lo, pos);
ans += get(pos, hi);
ss.insert(pos);
} else {
ans -= get(lo, pos);
ans -= get(pos, hi);
ans += get(lo, hi);
ss.erase(ss.find(pos));
}
}
s[pos] = t[0];
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int maximum(int a, int b) {
if (a > b)
return a;
else
return b;
}
bool cmp(const pair<int, int>& firs, const pair<int, int>& sec) {
return firs.first < sec.first;
}
long long int in[300005] = {0};
int mark[300005] = {0};
long long int fact(long long int n) {
long long int i, ans = 1;
for (i = 1; i <= n; i++) ans = (((ans) % 1000000007) * i) % 1000000007;
return ans % 1000000007;
}
long long int power(long long int a, long long int b) {
long long int ans = 1, y = a;
while (b != 0) {
if (b & 1) ans = ((ans % 1000000007) * (y % 1000000007)) % 1000000007;
y = ((y % 1000000007) * (y % 1000000007)) % 1000000007;
b = b / 2;
}
return ans % 1000000007;
}
int main() {
long long int n, s, t, i, tm, ans;
scanf("%I64d", &n);
tm = 1;
long long int in[17] = {0, 1, 0, 18, 0, 1800,
0, 670320, 0, 734832000, 0, 890786230,
0, 695720788, 0, 150347555, 0};
printf("%I64d\n", in[n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const long long MOD = 1e9 + 7;
long long n_bits(long long n) {
long long x = __builtin_popcount(n);
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
int n;
cin >> n;
int x;
int a[n];
for (long long i = 0; i < (n); ++i) {
cin >> a[i];
}
set<int> s[4];
for (long long i = 0; i < (n); ++i) {
cin >> x;
s[x].insert(a[i]);
}
for (long long i = 0; i < (n); ++i) {
cin >> x;
s[x].insert(a[i]);
}
int l;
cin >> l;
while (l--) {
cin >> x;
if (s[x].size() == 0)
cout << -1 << " ";
else {
long long p = *(s[x].begin());
cout << p << " ";
for (int i = 1; i < 4; i++) {
s[i].erase(p);
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int d[3][2 * 100005];
int mark[3][2 * 100005];
char c;
struct node {
int x, y, d;
} tmp, tmp2;
queue<node> q;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= 2; i++)
for (int j = 1; j <= n; j++) {
scanf(" %c", &c);
if (c == '-') d[i][j] = 1;
}
for (int j = n + 1; j <= n + k; j++) {
d[1][j] = 1;
d[2][j] = 1;
}
tmp.x = 1;
tmp.y = 1;
tmp.d = 0;
q.push(tmp);
while (!q.empty()) {
tmp = q.front();
q.pop();
if (tmp.d >= tmp.y) continue;
if (tmp.y >= n) {
printf("YES\n");
return 0;
}
if (mark[tmp.x][tmp.y]) {
continue;
}
mark[tmp.x][tmp.y] = 1;
if (tmp.y - 2 > tmp.d && d[tmp.x][tmp.y - 1]) {
tmp2 = tmp;
tmp2.y -= 1;
tmp2.d += 1;
q.push(tmp2);
}
if (d[tmp.x][tmp.y + 1]) {
tmp2 = tmp;
tmp2.y += 1;
tmp2.d += 1;
q.push(tmp2);
}
if (d[3 - tmp.x][tmp.y + k]) {
tmp2 = tmp;
tmp2.x = 3 - tmp.x;
tmp2.y += k;
tmp2.d += 1;
q.push(tmp2);
}
}
printf("NO\n");
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.