solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
static string s = "000123231312";
int main() {
ll T;
cin >> T;
while (T--) {
ll n;
cin >> n;
if (n <= 3) {
cout << n << "\n";
continue;
}
if (n < 16) {
cout << ((n - 1) % 3 + 1) * 4 + (s[n - 4] - '0') << "\n";
continue;
}
ll t = n;
ll now = 4;
ll jc = 1;
while (now * 4 <= n) now *= 4, jc++;
n -= now;
static ll base[1000 + 110] = {3};
for (ll i = 1; i < jc; i++) base[i] = base[i - 1] * 4;
reverse(base + 1, base + jc);
vector<ll> v;
v.push_back((t - 1) % 3 + 1);
for (ll i = 1; i < jc; i++) {
v.push_back(s[n / base[i] * 3 + (n - n / base[i] * base[i]) % 3] - '0');
n %= base[i];
}
v.push_back(s[n % 12] - '0');
ll out = 0;
for (auto it : v) out = out * 4 + it;
cout << out << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long llu;
const unsigned int LIM = 1005;
int main() {
int n, m;
bool can = true;
cin >> n >> m;
char cmatrix[LIM][LIM];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> cmatrix[i][j];
int dist[LIM], Gpos[LIM], Spos[LIM], count[LIM] = {0}, ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (cmatrix[i][j] == 'G') Gpos[i] = j;
if (cmatrix[i][j] == 'S') Spos[i] = j;
}
dist[i] = Spos[i] - Gpos[i];
if (dist[i] < 0) can = false;
}
if (can) {
for (int i = 0; i < n; i++) count[dist[i]]++;
for (int i = 1; i < LIM; i++)
if (count[i]) ans++;
cout << ans << "\n";
} else {
cout << "-1\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
void solve() {
cout << setprecision(15);
long long a, b, w, x, c, ans = 0;
cin >> a >> b >> w >> x >> c;
if (c - a <= 0)
cout << 0;
else
cout << c - a + ceil((((c - a) * x - b) * 1.0) / (w - x));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long c(int n, int k) {
if (k > n) return 0;
if (k * 2 > n) k = n - k;
if (k == 0) return 1;
long long result = n;
for (int i = 2; i <= k; ++i) {
result *= (n - i + 1);
result /= i;
}
return result;
}
int main() {
int n, m, t;
long long tot = 0;
cin >> n >> m >> t;
for (int b = 4; b <= n; ++b) {
int g = t - b;
if (g >= 1) {
tot += c(n, b) * c(m, g);
}
}
cout << tot << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using std::pair;
using std::vector;
vector<int64_t> ReadInput(std::istream& in_stream = std::cin);
void WriteAnswer(size_t min, size_t max, std::ostream& out_stream = std::cout);
pair<size_t, size_t> GetRange(const vector<int64_t>& input);
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
auto input = ReadInput();
auto result = GetRange(input);
WriteAnswer(result.first, result.second);
return 0;
}
vector<int64_t> Power2();
pair<vector<size_t>, vector<size_t>> ChainsExtra(const vector<int64_t>& input);
template <class Integral, class Functional, class Check>
Integral BinSearch(Integral left, Integral right, Functional func, Check check);
pair<size_t, size_t> GetRange(const vector<int64_t>& input) {
auto chains_extra = ChainsExtra(input);
vector<size_t> chains = std::move(chains_extra.first);
vector<size_t> extra = std::move(chains_extra.second);
size_t sum_chains = 0, sum_extra = 0;
for (size_t i = chains.size(); i > 0;
--i, sum_chains += chains[i], sum_extra += extra[i]) {
if (sum_extra > sum_chains) {
return {1, 0};
}
}
if (sum_extra > sum_chains) {
return {1, 0};
}
size_t min = sum_chains, max = sum_chains;
for (size_t i = 0; i < chains.size(); ++i) {
if (min - chains[i] >= sum_extra + chains[i] * i) {
min -= chains[i];
sum_extra += chains[i] * i;
} else {
auto enouht = [min, &chains, sum_extra, sum_chains, i](size_t remove) {
return min - remove >= sum_extra + remove * i;
};
auto diff = [](size_t l, size_t r) { return r <= l + 1; };
min -= BinSearch(size_t(0), chains[i], enouht, diff);
break;
}
}
return {min, max};
}
template <class Integral, class Functional, class Check>
Integral BinSearch(Integral left, Integral right, Functional func, Check check);
pair<vector<size_t>, vector<size_t>> ChainsExtra(const vector<int64_t>& input) {
vector<int64_t> pow2 = Power2();
vector<size_t> count_pow2(pow2.size(), 0);
vector<size_t> extra(pow2.size(), 0);
auto diff = [](size_t l, size_t r) { return r <= l + 1; };
for (auto elem : input) {
size_t pos = BinSearch(
size_t(0), pow2.size(),
[&pow2, elem](size_t pos) { return pow2[pos] <= elem; }, diff);
if (elem == pow2[pos]) {
++count_pow2[pos];
} else {
++extra[pos + 1];
}
}
auto get_last = [&count_pow2]() {
for (int i = 0; i < count_pow2.size(); ++i) {
if (count_pow2[i] == 0) {
return i;
}
}
return static_cast<int>(count_pow2.size());
};
vector<size_t> chains(pow2.size(), 0);
while (get_last() != 0) {
auto pos = get_last();
auto chains_count =
*std::min_element(count_pow2.begin(), count_pow2.begin() + pos);
chains[pos] = chains_count;
std::for_each(count_pow2.begin(), count_pow2.begin() + pos,
[chains_count](size_t& count) { count -= chains_count; });
}
for (size_t i = 0; i < pow2.size(); ++i) {
extra[i] += count_pow2[i];
}
return {chains, extra};
}
template <class Integral, class Functional, class Check>
Integral BinSearch(Integral left, Integral right, Functional func,
Check check) {
auto dir = func(left);
while (!check(left, right)) {
Integral mid = (left + right) / 2;
if (func(mid) == dir) {
left = mid;
} else {
right = mid;
}
}
return left;
}
vector<int64_t> Power2() {
std::vector<int64_t> power2{1};
while (power2.back() < 1ll * 2000 * 1000 * 1000 * 1000) {
power2.push_back(power2.back() * 2);
}
return power2;
}
void WriteAnswer(size_t min, size_t max, std::ostream& out_stream) {
if (min > max) {
out_stream << -1;
return;
}
for (size_t i = min; i <= max; ++i) {
std::cout << i << ' ';
}
}
vector<int64_t> ReadInput(std::istream& in_stream) {
size_t input_size;
in_stream >> input_size;
vector<int64_t> input(input_size);
for (auto& elem : input) {
in_stream >> elem;
}
return input;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int __SIZE = (1 << 21) + 1;
char ibuf[__SIZE], *iS, *iT, obuf[__SIZE], *oS = obuf, *oT = oS + __SIZE - 1,
__c, qu[55];
int __f, qr, _eof;
inline void flush() { fwrite(obuf, 1, oS - obuf, stdout), oS = obuf; }
inline void gc(char& x) {
x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void pc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
inline void pstr(const char* s) {
int __len = strlen(s);
for (__f = 0; __f < __len; ++__f) pc(s[__f]);
}
inline void gstr(char* s) {
for (__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
__c < 32 || __c > 126 || __c == ' ';)
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
for (; __c > 31 && __c < 127 && __c != ' ';
++s, __c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
*s = __c;
*s = 0;
}
template <class I>
inline bool gi(I& x) {
_eof = 0;
for (__f = 1,
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
(__c < '0' || __c > '9') && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) {
if (__c == '-') __f = -1;
_eof |= __c == EOF;
}
for (x = 0; __c <= '9' && __c >= '0' && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (__c & 15), _eof |= __c == EOF;
x *= __f;
return !_eof;
}
template <class I>
inline void print(I x) {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) pc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::gc;
using io::gi;
using io::gstr;
using io::pc;
using io::print;
using io::pstr;
using ll = long long;
using pii = pair<int, int>;
const int MOD = 1000000007;
vector<vector<int>> xw = {{337, 149, 47, 293, 11, 409, 79, 89, 23},
{271, 457, 347, 577, 163, 157, 433},
{613, 547, 241, 239, 331, 617, 101},
{41, 229, 487, 179, 31, 431, 181, 191},
{311, 131, 227, 17, 97, 13, 167, 601},
{233, 607, 443, 193, 439, 313, 401},
{349, 19, 83, 113, 73, 283, 449, 151},
{419, 379, 467, 61, 173, 103, 569},
{503, 593, 397, 359, 277, 7, 257},
{139, 461, 491, 353, 5, 251, 37, 29},
{499, 389, 373, 263, 269, 599, 197},
{521, 109, 2, 619, 67, 421, 317, 587},
{541, 557, 523, 281, 367, 53, 479},
{307, 199, 211, 383, 59, 571, 563},
{463, 509, 3, 71, 43, 127, 223, 137, 107}};
ll ask(ll x) {
cout << "? " << x << endl;
ll v;
cin >> v;
return v;
}
signed main() {
int t;
cin >> t;
while (t--) {
vector<int> prbpr;
for (const vector<int>& t : xw) {
ll pr = 1;
for (const int& j : t) pr *= j;
ll ans = ask(pr);
for (const int& j : t)
if (ans % j == 0) prbpr.push_back(j);
}
int ans = 1;
vector<pair<ll, ll>> jj;
for (const int& v : prbpr) {
int d = 1;
while (1ll * d * v < 1000000000) d *= v;
jj.push_back({d, v});
}
while (jj.size()) {
if (jj.size() >= 2) {
auto x = jj.back();
jj.pop_back();
auto y = jj.back();
jj.pop_back();
ll res = ask(x.first * y.first);
int cn1 = 0;
while (res % x.second == 0) cn1++, res /= x.second;
int cn2 = 0;
while (res % y.second == 0) cn2++, res /= y.second;
ans *= cn1 + 1;
ans *= cn2 + 1;
} else {
auto x = jj.back();
jj.pop_back();
ll res = ask(x.first);
int cn1 = 0;
while (res % x.second == 0) cn1++, res /= x.second;
ans *= cn1 + 1;
}
}
cout << "! " << max(ans * 2, ans + 7) << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 2e9;
const int MOD = 1e9 + 7;
const double Pi = 3.141592653589793;
const int N = 1e3 + 5;
int w[N][N], n, k, res = 0;
void solve() {
int win;
for (int i = (int)1; i <= (int)n; i++) {
win = 0;
for (int j = (int)1; j <= (int)n; j++) {
if (w[j][i] == 0 && i != j) {
w[i][j] = 1;
win++;
}
if (win == k) break;
}
if (win != k) {
cout << -1;
exit(0);
}
}
}
int main() {
cin >> n >> k;
solve();
for (int i = (int)1; i <= (int)n; i++)
for (int j = (int)1; j <= (int)n; j++) res += w[i][j];
cout << res << endl;
for (int i = (int)1; i <= (int)n; i++)
for (int j = (int)1; j <= (int)n; j++)
if (w[i][j] == 1) printf("%i %i\n", i, j);
}
| 3 |
#include <bits/stdc++.h>
#define mp std::make_pair
#define pb push_back
#define fi first
#define se second
#define gc getchar
#define pc putchar
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef std::pair <int, int> pii;
const int mod = 1000000007;
const int max_N = 4117649;
const int mod1 = 998244353;
const int base1 = 666623333;
const int mod2 = 1004535809;
const int base2 = 19260817;
int n, q, s1_len, s3_len, T_len, cut, tax[100343][26];
char s1[max_N], s2[max_N], s3[max_N], T[max_N];
ll Hashl1[max_N / 3], Hashr1[max_N / 3], Hashl2[max_N / 3], Hashr2[max_N / 3];
ll power1[max_N / 3], power2[max_N / 3];
bool matchl[max_N], matchr[max_N];
int read() {
char c = getchar(); int ans = 0; bool flag = true;
while (!isdigit(c)) flag &= (c != '-'), c = gc();
while (isdigit(c)) ans = ans * 10 + c - '0', c = gc();
return flag ? ans : -ans;
}
void Write(int x) {
static char _[16], top = 0; static div_t _div;
while (!top || x) _div = div(x, 10), _[++top] = _div.rem + '0', x = _div.quot;
while (top) pc(_[top--]);
}
int min(int x, int y) {return x < y ? x : y;}
int max(int x, int y) {return x > y ? x : y;}
void _min(int &x, int y) {if (x > y) x = y;}
void _max(int &x, int y) {if (x < y) x = y;}
ll power(ll x, int y, ll ans = 1) {
for (; y; y >>= 1, x = x * x % mod)
if (y & 1) ans = ans * x % mod;
return ans;
}
int ctz(int x) {
int ans = 0;
if (!(x & 65535)) ans += 16, x >>= 16;
if (!(x & 255)) ans += 8, x >>= 8;
if (!(x & 15)) ans += 4, x >>= 4;
if (!(x & 3)) ans += 2, x >>= 2;
return ans + !(x & 1);
}
char test(int x) {
if ((x - 1) % (s1_len + 1) < s1_len) return s1[(x - 1) % (s1_len + 1) + 1];
return s2[ctz(x / (s1_len + 1)) + 1];
}
int get_match() {
static int nxt[max_N]; int ans = 0;
for (int i = 2; i <= s3_len; i++) {
int j = nxt[i - 1];
while (j && s3[j + 1] != s3[i]) j = nxt[j];
nxt[i] = j + (s3[j + 1] == s3[i]);
}
for (int i = 1, j = 0; i <= T_len; i++)
if (s3[j + 1] == T[i]) {
j++;
if (j == s3_len) ans++, j = nxt[j];
}
else {
while (j && s3[j + 1] != T[i]) j = nxt[j];
j += (s3[j + 1] == T[i]);
}
return ans;
}
int main() {
n = read(), q = read(); scanf("%s%s", s1 + 1, s2 + 1);
s1_len = strlen(s1 + 1); int tmp = s1_len;
for (int i = power1[0] = power2[0] = 1; i <= 1000000; i++)
power1[i] = power1[i - 1] * base1 % mod1, power2[i] = power2[i - 1] * base2 % mod2;
while (s1_len < 2050000)
std::copy(s1 + 1, s1 + s1_len + 1, s1 + s1_len + 2),
s1[s1_len + 1] = s2[++cut], s1_len = s1_len * 2 + 1;
std::swap(s1_len, tmp);
for (int i = 1; i <= 1000000; i++) {
Hashl1[i] = (Hashl1[i - 1] * base1 + test(i)) % mod1,
Hashl2[i] = (Hashl2[i - 1] * base2 + test(i)) % mod2,
Hashr1[i] = (Hashr1[i - 1] * base1 + test(tmp + 1 - i)) % mod1,
Hashr2[i] = (Hashr2[i - 1] * base2 + test(tmp + 1 - i)) % mod2;
}
for (int i = cut + 1; i <= n; i++) {
std::copy(tax[i - 1], tax[i - 1] + 26, tax[i]);
tax[i][s2[i] - 'a'] = (tax[i][s2[i] - 'a'] + power((mod + 1) / 2, i)) % mod;
}
for (int _ = 1, K; _ <= q; _++) {
K = read(), scanf("%s", s3 + 1), s3_len = strlen(s3 + 1); int ans = 0;
for (int i = 0, cur = s1_len; i <= min(cut, K); i++, cur = cur * 2 + 1) {
if (cur < s3_len) continue;
if (i == 0) std::copy(s1 + 1, s1 + 1 + s1_len, T + 1), T_len = s1_len;
else {
int low = max(1, (cur + 1) / 2 - s3_len + 1);
int up = min(cur, (cur + 1) / 2 + s3_len - 1);
T_len = up - low + 1, std::copy(s1 + low, s1 + up + 1, T + 1);
}
ans = (ans + power(2, K - i, get_match())) % mod;
}
if (K > cut) {
for (int i = 0; i <= s3_len + 1; i++) matchl[i] = matchr[i] = true;
for (int i = s3_len, prod = 0; i; i--)
prod = (prod + s3[i] * power1[s3_len - i]) % mod1,
matchl[s3_len - i + 1] &= (prod == Hashl1[s3_len - i + 1]);
for (int i = s3_len, prod = 0; i; i--)
prod = (prod + s3[i] * power2[s3_len - i]) % mod2,
matchl[s3_len - i + 1] &= (prod == Hashl2[s3_len - i + 1]);
for (int i = 1, prod = 0; i <= s3_len; i++)
prod = (prod + s3[i] * power1[i - 1]) % mod1,
matchr[i] &= (prod == Hashr1[i]);
for (int i = 1, prod = 0; i <= s3_len; i++)
prod = (prod + s3[i] * power2[i - 1]) % mod2,
matchr[i] &= (prod == Hashr2[i]);
for (int i = 1; i <= s3_len; i++) if (matchl[s3_len - i] && matchr[i - 1])
ans = (ans + tax[K][s3[i] - 'a'] * power(2, K)) % mod;
}
Write(ans), pc('\n');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 100000 + 10;
long long a[maxn];
long long n;
struct node {
int num, pos;
} b[maxn];
int cmp(node p, node q) {
if (p.num == q.num)
return p.pos < q.pos;
else
return p.num < q.num;
}
int main() {
while (scanf("%d", &n) != EOF) {
int x;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
b[i].num = x;
b[i].pos = i;
}
sort(b, b + n, cmp);
int k;
k = b[0].num;
a[b[0].pos] = b[0].num;
for (int i = 1; i < n; i++) {
if (b[i].num <= k) {
a[b[i].pos] = k + 1;
k++;
} else {
a[b[i].pos] = b[i].num;
k = b[i].num;
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using li = long long;
using ld = long double;
using pii = pair<int, int>;
const int N = 73;
const int INF = 1e9;
int dp[N][N][N];
vector<int> p[N][N][N];
int n;
char g[N][N];
int main() {
int a, b, c;
cin >> n >> a >> b >> c;
a--;
b--;
c--;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cin >> g[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int l = 0; l < n; l++) dp[i][j][l] = -1;
dp[0][1][2] = 0;
p[0][1][2] = {-1, -1, -1};
queue<vector<int>> q;
q.push({0, 1, 2});
while (!q.empty()) {
vector<int> x = q.front();
q.pop();
sort(x.begin(), x.end());
for (int i = 0; i < 3; i++) {
int a1 = x[i], b1 = x[(i + 1) % 3], c1 = x[(i + 2) % 3];
char w = g[b1][c1];
for (int j = 0; j < n; j++)
if (g[a1][j] == w && j != a1 && j != b1 && j != c1) {
vector<int> y = {j, b1, c1};
sort(y.begin(), y.end());
if (dp[y[0]][y[1]][y[2]] == -1) {
q.push(y);
dp[y[0]][y[1]][y[2]] = dp[x[0]][x[1]][x[2]] + 1;
p[y[0]][y[1]][y[2]] = {a1, b1, c1};
}
}
}
}
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
if (dp[a][b][c] == -1) {
cout << -1;
return 0;
}
cout << dp[a][b][c] << endl;
while (p[a][b][c][0] != -1) {
vector<int> nxt = p[a][b][c];
set<int> s1 = {a, b, c};
set<int> s2(nxt.begin(), nxt.end());
int x, y;
for (auto x1 : s1)
if (s2.count(x1) == 0) x = x1;
for (auto y1 : s2)
if (s1.count(y1) == 0) y = y1;
cout << x + 1 << ' ' << y + 1 << endl;
sort(nxt.begin(), nxt.end());
a = nxt[0], b = nxt[1], c = nxt[2];
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
if (f) x = -x;
}
template <typename T>
inline void write(T x) {
static int stk[30], top = 0;
if (x == 0) putchar('0');
if (x < 0) putchar('-'), x = -x;
while (x) stk[++top] = x % 10, x /= 10;
while (top) putchar(stk[top--] + '0');
return;
}
const int N = 5e5;
int match[N];
int vis[N];
struct Node {
int to, nxt, w;
} e[N];
int head[N], cnt;
int n, m;
int co[N];
inline void add(int x, int y) {
e[++cnt].nxt = head[x];
e[cnt].to = y;
head[x] = cnt;
}
struct node {
int id, w;
friend bool operator<(node x, node y) { return x.w > y.w; }
} a[N];
int dfs(int x, int id) {
for (int i = head[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (vis[y] < id) {
vis[y] = id;
if (!match[y]) {
match[y] = x;
return 1;
}
if (co[y] <= 100) {
co[y]++;
if (dfs(match[y], id)) {
match[y] = x;
return 1;
}
}
}
}
return 0;
}
int main() {
read(n), read(m);
for (int i = 1, x, y, z; i <= m; ++i) {
read(x), read(y), read(z);
add(i, y + m);
add(i, x + m);
a[i].w = z;
a[i].id = i;
}
long long ans = 0;
sort(a + 1, a + m + 1);
for (int i = 1; i <= m; ++i) {
if (dfs(a[i].id, i)) ans += a[i].w;
}
write(ans);
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
static int r, sign;
static char c;
r = 0, sign = 1;
do c = getchar();
while (c != '-' && (c < '0' || c > '9'));
if (c == '-') sign = -1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + (int)(c - '0'), c = getchar();
return sign * r;
}
template <typename T>
inline void print(T *a, int n) {
for (int i = 1; i < n; ++i) cout << a[i] << " ";
cout << a[n] << endl;
}
const int mod = (int)1e9 + 7;
struct hashInt {
int x;
hashInt() {}
hashInt(int _x) : x(_x) {}
inline hashInt operator+(const hashInt &y) const {
int z = x + y.x;
if (z >= mod) z -= mod;
if (z < 0) z += mod;
return hashInt(z);
}
inline hashInt operator-(const hashInt &y) const {
int z = x - y.x;
if (z >= mod) z -= mod;
if (z < 0) z += mod;
return hashInt(z);
}
inline hashInt operator*(const hashInt &y) const {
return hashInt((long long)x * y.x % mod);
}
};
struct edge {
int next, node;
hashInt w;
} e[100100 << 1 | 1];
int head[100100 + 1], tot = 0;
inline void addedge(int a, int b, int w) {
e[++tot].next = head[a];
head[a] = tot, e[tot].node = b, e[tot].w = w;
}
struct DP {
hashInt sum, sqr;
DP() {}
DP(int _s, int _q) : sum(_s), sqr(_q) {}
DP(hashInt _s, hashInt _q) : sum(_s), sqr(_q) {}
} up[100100 + 1], down[100100 + 1], downex[100100 + 1];
int n, size[100100 + 1];
inline hashInt delta(const DP &x, int n, hashInt b) {
return x.sqr + b * b * n + b * 2 * x.sum;
}
void preUp(int x, int f) {
size[x] = 1, up[x].sum = up[x].sqr = 0;
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
preUp(node, x);
size[x] += size[node];
up[x].sum = up[x].sum + up[node].sum + e[i].w * size[node];
up[x].sqr = up[x].sqr + delta(up[node], size[node], e[i].w);
}
}
void preDown(int x, int f) {
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
DP cur;
cur.sum = down[x].sum + up[x].sum - up[node].sum - e[i].w * size[node];
cur.sqr = down[x].sqr + up[x].sqr - delta(up[node], size[node], e[i].w);
downex[node] = cur;
down[node].sum = cur.sum + e[i].w * (n - size[node]);
down[node].sqr = delta(cur, n - size[node], e[i].w);
preDown(node, x);
}
}
int p[18 + 1][100100 + 1], logn, dep[100100 + 1];
hashInt dis[100100 + 1], dissum[100100 + 1], dissqr[100100 + 1];
void preDA(int x, int f) {
p[0][x] = f;
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
dep[node] = dep[x] + 1;
dis[node] = dis[x] + e[i].w;
dissum[node] = dissum[x] + dis[node];
dissqr[node] = dissqr[x] + dis[node] * dis[node];
preDA(node, x);
}
}
inline int LCA(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
for (int i = logn; i >= 0; --i)
if (dep[x] <= dep[p[i][y]]) y = p[i][y];
if (x == y) return x;
for (int i = logn; i >= 0; --i)
if (p[i][x] != p[i][y]) x = p[i][x], y = p[i][y];
return p[0][x];
}
inline int LCA2(int x, int y) {
for (int i = logn; i >= 0; --i)
if (dep[x] < dep[p[i][y]]) y = p[i][y];
return y;
}
vector<pair<int, int> > Q[100100 + 1];
int q, ans[100100 + 1], seq[100100 + 1], cnt = 0;
DP pre[100100 + 1], suf[100100 + 1];
struct BIT {
hashInt a[100100 + 1];
inline void modify(int x, hashInt w) {
for (; x <= n; x += x & -x) a[x] = a[x] + w;
}
inline hashInt query(int x) {
hashInt r = 0;
for (; x > 0; x -= x & -x) r = r + a[x];
return r;
}
} sufsum, sufsqr;
void dfs(int x, int f) {
for (int i = 0; i < Q[x].size(); ++i) {
int node = Q[x][i].first, id = Q[x][i].second;
int p = LCA(x, node);
hashInt b = dis[node] - dis[p];
b = b * b;
}
for (int i = head[x]; i; i = e[i].next) {
int node = e[i].node;
if (node == f) continue;
seq[++cnt] = x;
pre[cnt].sum = pre[cnt - 1].sum + e[i].w * (cnt - 1);
pre[cnt].sqr = delta(pre[cnt - 1], cnt - 1, e[i].w);
dfs(node, x);
--cnt;
}
}
int main(int argc, char *argv[]) {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
addedge(x, y, w), addedge(y, x, w);
}
preUp(1, 0);
preDown(1, 0);
dep[1] = 1, preDA(1, 0);
logn = (int)(log((double)n) / log(2.0));
for (int i = 1; i <= logn; ++i)
for (int j = 1; j <= n; ++j) p[i][j] = p[i - 1][p[i - 1][j]];
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
int p = LCA(x, y);
hashInt d = dis[x] + dis[y] - dis[p] * 2;
hashInt ans = 0;
if (p == y) {
ans = delta(down[y], n - size[y], d);
ans = up[x].sqr + down[x].sqr - ans * 2;
} else {
ans = delta(up[y], size[y], d);
ans = ans * 2 - up[x].sqr - down[x].sqr;
}
printf("%d\n", ans.x);
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000LL;
int a[300010];
long long dp[5010][5010];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int gsize = n / k;
int l = n % k;
int s = k - l;
for (int i = 0; i <= k; i++) {
for (int j = 0; j <= min(s, i); j++) {
dp[j][i - j] = INF;
}
}
long long ans = INF;
dp[0][0] = 0;
for (int i = 1; i <= k; i++) {
for (int j = 0; j <= min(s, i); j++) {
int pos = i * gsize + (i - j) - 1;
if (j > 0)
dp[j][i - j] =
min(dp[j][i - j], dp[j - 1][i - j] + a[pos] - a[pos - gsize + 1]);
if (i - j > 0)
dp[j][i - j] =
min(dp[j][i - j], dp[j][i - j - 1] + a[pos] - a[pos - gsize]);
if (i == k && s == j) {
ans = min(ans, dp[j][k - j]);
}
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
void test() {
long long n;
cin >> n;
long long a[n];
bool ok = true;
cin >> a[0];
for (long long i = 1; i < n; i++) {
cin >> a[i];
if (a[i] - a[i - 1] > 1) ok = false;
}
ok ? cout << "Yes\n" : cout << "No\n";
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
cin >> t;
while (t--) {
test();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
const int mod = 1e9 + 7;
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0)
if (b & 1) {
res = (long long)(res * 1ll * a);
--b;
} else {
a = (long long)(a * 1ll * a);
b >>= 1;
}
return (long long)res;
}
vector<vector<int>> pref;
bool check(int ind_l, int ind_r) {
if (ind_l == 0) {
if (pref[0][ind_r] != 0)
return false;
else
return true;
} else if (pref[0][ind_r] - pref[0][ind_l - 1] != 0)
return false;
else
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
string s;
cin >> s;
int ind_x = -1, ind_y = -1;
int ans;
for (int i = 0; i < n; i++) {
if (s[i] == '>') {
ans = i;
break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '<') {
ans = min(n - i - 1, ans);
break;
}
}
if (ans == 1e9) ans = 0;
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s = "AHITUVWXYMO";
int f(char ch) {
for (int i = 0; i < s.size(); i++) {
if (ch == s[i]) {
return 0;
}
}
return 1;
}
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] != s[s.size() - 1 - i] || f(s[i]) != 0) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (auto &it : a) cin >> it;
for (auto &it : b) cin >> it;
vector<int> c(n);
for (int i = 0; i < n; ++i) {
c[i] = a[i] - b[i];
}
sort(c.begin(), c.end());
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (c[i] <= 0) continue;
int pos = lower_bound(c.begin(), c.end(), -c[i] + 1) - c.begin();
ans += i - pos;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const int MAXM = 1000005;
const int dx[] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy[] = {1, 0, -1, 1, -1, 1, 0, -1};
int fa[MAXM];
int id_cnt;
int id[MAXN][MAXN];
int S, T, n, m, Q;
int st[MAXN];
int top, cnt;
int blkx[MAXN];
int blky[MAXN];
char ch[MAXN][MAXN];
bool haveans = 1;
set<pair<int, int> > s;
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline int find2(int x) { return fa[x] == x ? x : find2(fa[x]); }
inline void merge(int x, int y) { fa[find2(x)] = fa[find2(y)]; }
inline pair<int, int> make(int x, int y) {
return make_pair(min(x, y), max(x, y));
}
int main() {
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= n; i++) scanf("%s", ch[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) id[i][j] = ++id_cnt;
S = ++id_cnt;
T = ++id_cnt;
for (int i = 1; i <= id_cnt; i++) fa[i] = i;
for (int i = 1; i <= n; i++) {
id[i][0] = S;
id[i][m + 1] = T;
ch[i][0] = ch[i][m + 1] = '#';
}
for (int i = 1; i <= m; i++) {
id[0][i] = T;
id[n + 1][i] = S;
ch[0][i] = ch[n + 1][i] = '#';
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '#')
for (int k = 0; k < 8; k++) {
int x = i + dx[k], y = j + dy[k];
if (ch[x][y] == '#') fa[find(id[i][j])] = find(id[x][y]);
}
pair<int, int> final = make_pair(find(S), find(T));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i == 1 && j == 1) continue;
if (i == n && j == m) continue;
for (int k = 0; k < 8; k++)
for (int l = k + 1; l < 8; l++) {
int f1 = find(id[i + dx[k]][j + dy[k]]);
int f2 = find(id[i + dx[l]][j + dy[l]]);
pair<int, int> tp = make(f1, f2);
s.insert(tp);
if (tp == final) haveans = false, i = n + 1, j = m + 1;
}
}
if (!haveans) {
while (Q--) puts("NO");
return 0;
}
while (Q--) {
scanf("%d", &cnt);
for (int i = 1; i <= cnt; i++) {
scanf("%d%d", &blkx[i], &blky[i]);
ch[blkx[i]][blky[i]] = '#';
st[++top] = find(id[blkx[i]][blky[i]]);
for (int k = 0; k < 8; k++)
if (ch[blkx[i] + dx[k]][blky[i] + dy[k]] == '#')
st[++top] = find(id[blkx[i] + dx[k]][blky[i] + dy[k]]);
}
st[++top] = find(S), st[++top] = find(T);
sort(st + 1, st + top + 1);
top = unique(st + 1, st + top + 1) - st - 1;
for (int i = 1; i <= cnt; i++)
for (int k = 0; k < 8; k++)
if (ch[blkx[i] + dx[k]][blky[i] + dy[k]] == '#')
merge(id[blkx[i] + dx[k]][blky[i] + dy[k]], id[blkx[i]][blky[i]]);
bool ans = true;
for (int i = 1; i <= top && ans; i++)
if (find2(st[i]) == find2(S))
for (int j = 1; j <= top && ans; j++)
if (find2(st[j]) == find2(T) && s.find(make(st[i], st[j])) != s.end())
ans = false;
puts(ans ? "YES" : "NO");
fflush(stdout);
for (int i = 1; i <= cnt; i++) ch[blkx[i]][blky[i]] = '.';
while (top) fa[st[top]] = st[top], top--;
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct ss {
int x, y, z, c;
} s[50009];
bool cmp(ss a, ss b) {
if (a.z == b.z) {
if (a.y == b.y) return a.x < b.x;
return a.y < b.y;
}
return a.z < b.z;
}
bool b[50009];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &s[i].x, &s[i].y, &s[i].z);
s[i].c = i + 1;
}
sort(s, s + n, cmp);
for (int i = 1; i < n; i++) {
if (s[i - 1].y == s[i].y && s[i - 1].z == s[i].z) {
b[i - 1] = b[i] = 1;
printf("%d %d\n", s[i].c, s[i - 1].c);
i++;
}
}
vector<int> v;
for (int i = 0; i < n; i++)
if (b[i] == 0) v.push_back(i);
int vlen = v.size();
for (int i = 1; i < vlen; i++) {
if (s[v[i - 1]].z == s[v[i]].z) {
b[v[i - 1]] = b[v[i]] = 1;
printf("%d %d\n", s[v[i]].c, s[v[i - 1]].c);
i++;
}
}
v.clear();
for (int i = 0; i < n; i++)
if (b[i] == 0) v.push_back(i);
vlen = v.size();
for (int i = 0; i < vlen; i += 2) printf("%d %d\n", s[v[i]].c, s[v[i + 1]].c);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct node {
int v, next, dis, flow;
} edge[2000005];
int head[N];
int tot = -1;
int pre[N], last[N], dis[N], vis[N], flow[N], a[N], c[N], last1[N];
void addedge(int u, int v, int d, int f) {
edge[++tot].next = head[u];
head[u] = tot;
edge[tot].v = v;
edge[tot].dis = d;
edge[tot].flow = f;
edge[++tot].next = head[v];
head[v] = tot;
edge[tot].v = u;
edge[tot].dis = -d;
edge[tot].flow = 0;
}
int SPFA(int s, int t) {
memset(dis, 127, sizeof(dis));
memset(vis, 0, sizeof(vis));
memset(flow, 127, sizeof(flow));
queue<int> Q;
pre[t] = -1;
dis[s] = 0;
vis[s] = 1;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
vis[u] = 0;
for (int e = head[u]; e != -1; e = edge[e].next) {
int v = edge[e].v;
if (dis[v] > dis[u] + edge[e].dis && edge[e].flow > 0) {
dis[v] = dis[u] + edge[e].dis;
pre[v] = u;
last[v] = e;
flow[v] = min(flow[u], edge[e].flow);
if (vis[v] == 0) {
vis[v] = 1, Q.push(v);
}
}
}
}
if (pre[t] == -1)
return 0;
else
return 1;
}
int main() {
int n, m, s, t, i, j, o, l, K;
memset(head, -1, sizeof(head));
scanf("%d %d", &n, &K);
s = 2 * n + 1;
t = 2 * n + 2;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1; i <= n; i++) {
addedge(s, i, c[a[i]], 1);
if (i != 1) addedge(i - 1, i, 0, K - 1);
addedge(i, i + n, 0, 1);
if (last1[a[i]]) addedge(i - 1, last1[a[i]] + n, -c[a[i]], 1);
addedge(i + n, t, 0, 1);
last1[a[i]] = i;
}
int maxflow = 0, mincost = 0;
while (SPFA(s, t)) {
mincost += flow[t] * dis[t];
maxflow += flow[t];
int p = t;
while (p != s) {
edge[last[p]].flow -= flow[t];
edge[last[p] ^ 1].flow += flow[t];
p = pre[p];
}
}
printf("%d\n", mincost);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U>
using Pa = pair<T, U>;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vec<T>>;
constexpr ll mod = 1e9 + 7;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
friend ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
friend istream& operator>>(istream& is, mint& a) {
ll t;
is >> t;
a = mint(t);
return (is);
}
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
mint n = N;
mint m = M;
if (M == 1) {
cout << N + 1 << "\n";
return 0;
}
mint ans = m.pow(N);
mint p = m / (m - 1) + 1;
cerr << ans << "\n";
for (int x = 0; x < N; x++) {
mint now = p.pow(N - x - 1);
now *= (m - 1).pow(N - x - 1) * m.pow(x + 1);
ans += now;
}
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int size = 2 * (int)1e5 + 1, ans = 0;
vector<vector<int>> graph(size, vector<int>(0));
void dfs(int v, vector<bool>& mark) {
mark[v] = true;
int res = -1;
for (int u : graph[v]) {
++res;
dfs(u, mark);
}
ans += max(0, res);
}
int main() {
int n;
cin >> n;
for (int i = 1, t; i <= n; ++i) {
cin >> t;
graph[t].push_back(i);
}
vector<bool> mark(size, false);
for (int i = 0; i < size; ++i) {
if (!mark[i] && graph[i].size() > 0) {
++ans;
dfs(i, mark);
}
}
cout << ans;
}
| 2 |
#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 int read() {
int 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(int a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
const int N = 155;
struct matrix {
bitset<N> a[N];
} sum, zs, ans;
int n, m, sss;
pair<int, pair<int, int> > a[N];
matrix operator+(matrix &x, matrix &y) {
matrix ans;
for (int i = 0; i < n; i++) ans.a[i] = x.a[i];
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++)
if (x.a[i][k]) {
ans.a[i] |= y.a[k];
}
}
return ans;
}
matrix add(matrix ans, matrix zs, int k) {
for (; k; k >>= 1) {
if (k & 1) ans = ans + zs;
zs = zs + zs;
}
return ans;
}
matrix operator*(matrix &x, matrix &y) {
matrix ans;
for (int i = 0; i < n; i++) ans.a[i].reset();
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++)
if (x.a[i][k]) {
ans.a[i] |= y.a[k];
}
}
return ans;
}
matrix mul(matrix ans, matrix zs, int k) {
for (; k; k >>= 1) {
if (k & 1) ans = ans * zs;
zs = zs * zs;
}
return ans;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int u = read() - 1, v = read() - 1;
a[i].second = make_pair(u, v);
a[i].first = read();
}
sort(&a[1], &a[m + 1]);
a[m + 1].first = a[m].first + 1e9;
if (a[1].first) {
puts("Impossible");
return 0;
}
ans.a[0][0] = sum.a[0][0] = 1;
for (int i = 1; i <= m; i++)
if (a[i].first != a[i + 1].first) {
for (int j = 0; j < n; j++) zs.a[i].reset();
for (int j = 1; j <= i; j++)
zs.a[a[j].second.first][a[j].second.second] = 1;
matrix t = add(ans, zs, a[i + 1].first - a[i].first);
if (t.a[0][n - 1]) {
int l = a[i].first + 1, r = a[i + 1].first;
while (l < r) {
int mid = ((long long)l + r) >> 1;
if (add(ans, zs, mid - a[i].first).a[0][n - 1])
r = mid;
else
l = mid + 1;
}
writeln(l);
return 0;
}
sum = t;
ans = mul(ans, zs, a[i + 1].first - a[i].first);
}
puts("Impossible");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ar[n];
for (long long i = 0; i < n; i++) cin >> ar[i];
long long a = 0, b = 0, c = 0;
long long ans = 0;
if (n == 1 || n == 2)
ans = 1;
else {
long long count1 = 0, count2 = 0;
for (long long i = 0; i + 1 < n; i++) {
if (ar[i] < ar[i + 1]) count1++;
if (ar[i] > ar[i + 1]) count2++;
}
if (count1 == n - 1 || count2 == n - 1) ans = 1;
long long i = 0, j = n - 1;
while (ar[i] < ar[i + 1] && i < n - 1) i++;
while (ar[j] < ar[j - 1] && j > 0) j--;
if (i == j) ans = 1;
}
if (ans == 1)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int a;
cin >> a;
long long int arr[a];
long long int arr1[a];
for (int i = 0; i < a; i++) cin >> arr[i];
for (int i = 0; i < a; i++) cin >> arr1[i];
sort(arr, arr + a);
sort(arr1, arr1 + a);
for (int i = 0; i < a - 1; i++) cout << arr[i] << " ";
cout << arr[a - 1] << endl;
for (int i = 0; i < a - 1; i++) cout << arr1[i] << " ";
cout << arr1[a - 1] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[41];
int main() {
a[0] = 1;
for (int i = 1; i <= 12; i++) {
a[i] = a[i - 1] * 2;
}
a[13] = 8092;
for (int i = 14; i <= 35; i++) {
a[i] = a[i - 1] * 2;
}
cin >> n;
cout << a[n] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005, maxv = 1e5 + 5;
int n, a[maxn], dp[maxn][maxn], maxnum[maxv], maxmod[7];
bool vis[maxn][maxn];
int go(int x, int y) {
if (x > n || y > n) return (x && y ? 0 : -n);
int &ret = dp[x][y];
bool &done = vis[x][y];
if (done) return ret;
done = 1;
ret = 0;
for (int i = max(x, y) + 1; i <= n; i++) {
if (!x || abs(a[x] - a[i]) == 1 || a[x] % 7 == a[i] % 7)
ret = max(ret, 1 + go(i, y));
if (!y || abs(a[y] - a[i]) == 1 || a[y] % 7 == a[i] % 7)
ret = max(ret, 1 + go(x, i));
}
return ret;
}
int get(int i, int j) {
if (i < j) swap(i, j);
return dp[i][j];
}
int go_iter() {
int ans = 0;
for (int y = 0; y < n; y++) {
memset(maxnum, 0, sizeof maxnum);
memset(maxmod, 0, sizeof maxmod);
for (int x = 0; x <= n; x++)
if (x != y) {
int &ret = (x > y ? dp[x][y] : dp[y][x]);
if (x > y) {
ret = max(1 + maxnum[a[x] - 1], 1 + maxnum[a[x] + 1]);
if (y) ret = max(ret, 1 + dp[y][0]);
ret = max(ret, 1 + maxmod[a[x] % 7]);
}
if (x > 0) {
maxmod[a[x] % 7] = max(maxmod[a[x] % 7], ret);
maxnum[a[x]] = max(maxnum[a[x]], ret);
}
ans = max(ans, ret);
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cout << go_iter() << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j;
cin >> n;
long long M[n + 1][n + 1], a[n + 1];
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
cin >> M[i][j];
}
}
a[1] = (M[1][2] * M[1][3]) / M[2][3];
a[1] = sqrt(a[1]);
cout << a[1] << " ";
for (i = 2; i <= n; i++) {
cout << M[1][i] / a[1] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
#pragma GCC target("avx,avx2")
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t, class... A>
inline void read(t &x, A &...a) {
read(x);
read(a...);
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
long long A, B, C, S, ansA, ansB, ansC, ansS, pw[505][505], V, n, v[10005];
void dfs2(long long x, long long b, long long a) {
if (1.0 * b * b > V / a) return;
if (x > n) {
B = max(B, b);
return;
}
for (long long i = v[x]; ~i; i--) dfs2(x + 1, b * pw[x][i], a);
}
void dfs1(long long x, long long a) {
if (1.0 * a * a * a > V) return;
if (x > n) {
long long bc = V / a, lim = 4 * a * sqrt(bc) + 2 * bc;
if (lim >= ansS) return;
B = 0;
A = a;
dfs2(1, 1, A);
C = V / A / B;
S = (A * B + B * C + A * C) << 1;
if (S < ansS) {
ansS = S;
ansA = A;
ansB = B;
ansC = C;
}
return;
}
for (long long i = v[x]; ~i; i--) {
v[x] -= i;
dfs1(x + 1, a * pw[x][i]);
v[x] += i;
}
}
void doit() {
read(n);
V = 1;
for (long long i = 1, x, y; i <= n; i++) {
read(x, y);
v[i] = y;
pw[i][0] = 1;
for (long long j = 1; j <= y; j++) pw[i][j] = pw[i][j - 1] * x;
V *= pw[i][y];
}
ansS = 1ll << 62;
dfs1(1, 1);
write(ansS);
putchar(' ');
write(ansA);
putchar(' ');
write(ansB);
putchar(' ');
write(ansC);
puts("");
}
signed main() {
long long t;
read(t);
while (t--) doit();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 3e5 + 15;
int n, a[N], c[N];
vector<int> g[N];
void dfs(int v, int col) {
if (c[v] != -1) return;
c[v] = col;
for (int i : g[v]) dfs(i, !col);
}
bool tree() {
for (int i = 0, ggdem = n; i < ggdem; i++) g[i].clear();
fill(c, c + n, -1);
for (int i = 0, ggdem = n; i < ggdem; i++) {
if (a[i] != a[(i + 1) % n])
g[i].push_back((i + 1) % n), g[(i + 1) % n].push_back(i);
}
for (int i = 0, ggdem = n; i < ggdem; i++) dfs(i, 0);
for (int i = 0, ggdem = n; i < ggdem; i++)
for (int j : g[i])
if (c[i] == c[j]) return 0;
int mx = 1;
for (int i = 0, ggdem = n; i < ggdem; i++) mx = max(mx, c[i] + 1);
cout << mx << "\n";
for (int i = 0, ggdem = n; i < ggdem; i++)
cout << c[i] + 1 << " \n"[i == n - 1];
return 1;
}
void color() {
c[0] = 1;
for (int i = 1, ggdem = n; i < ggdem; i++) {
if (c[i - 1] == 1)
c[i] = 2;
else
c[i] = 1;
}
c[n - 1] = 3;
cout << 3 << "\n";
for (int i = 0, ggdem = n; i < ggdem; i++) cout << c[i] << " \n"[i == n - 1];
}
void solve() {
cin >> n;
for (int i = 0, ggdem = n; i < ggdem; i++) cin >> a[i];
if (!tree()) color();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1100][1100];
int b[5];
int c[5];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%1d", &a[i][j]);
memset(b, -1, sizeof(b));
bool judge = true;
for (int i = 0; i < n; i++) {
int c[2];
memset(c, -1, sizeof(c));
for (int j = 0; j < m; j++)
if (a[i][j] != 0) {
int temp = i % 2 + 1;
if ((b[a[i][j]] != -1 && b[a[i][j]] != temp) ||
(c[(j + 1) % 2] == a[i][j]) ||
c[j % 2] != a[i][j] && c[j % 2] != -1)
judge = false;
else {
c[j % 2] = a[i][j];
b[a[i][j]] = temp;
}
}
}
if (judge) {
int d = 0;
int s = 0;
for (int i = 1; i < 5; i++) {
if (b[i] == -1) continue;
if (b[i] % 2 == 0)
s++;
else
d++;
}
for (int i = 1; i < 5; i++) {
if (b[i] == -1) {
if (d < 2) {
b[i] = 1;
d++;
} else
b[i] = 2;
}
}
for (int i = 0; i < n; i++) {
int l = -1, r = -1;
for (int j = 1; j < 5; j++) {
if (i % 2 != b[j] % 2)
if (l == -1)
l = j;
else
r = j;
}
int now = 0;
for (int j = 0; j < m; j++) {
if (a[i][j] != 0) {
if (j % 2 == 0)
if (a[i][j] != l)
now = 0;
else
now = 1;
else if (a[i][j] != l)
now = 1;
else
now = 0;
}
}
for (int j = 0; j < m; j++)
if ((j + now) % 2 != 0)
printf("%d", l);
else
printf("%d", r);
puts("");
}
} else {
memset(b, -1, sizeof(b));
judge = true;
for (int j = 0; j < m; j++) {
int c[2];
memset(c, -1, sizeof(c));
for (int i = 0; i < n; i++)
if (a[i][j] != 0) {
int temp = j % 2 + 1;
if ((b[a[i][j]] != -1 && b[a[i][j]] != temp) ||
(c[(i + 1) % 2] == a[i][j]) ||
c[i % 2] != a[i][j] && c[i % 2] != -1)
judge = false;
else {
c[i % 2] = a[i][j];
b[a[i][j]] = temp;
}
}
}
if (judge) {
int d = 0;
int s = 0;
for (int i = 1; i < 5; i++) {
if (b[i] == -1) continue;
if (b[i] % 2 == 0)
s++;
else
d++;
}
for (int i = 1; i < 5; i++) {
if (b[i] == -1) {
if (d < 2) {
b[i] = 1;
d++;
} else
b[i] = 2;
}
}
for (int j = 0; j < m; j++) {
int l = -1, r = -1;
for (int i = 1; i < 5; i++) {
if (j % 2 != b[i] % 2)
if (l == -1)
l = i;
else
r = i;
}
int now = 0;
for (int i = 0; i < n; i++) {
if (a[i][j] != 0) {
if (i % 2 == 0)
if (a[i][j] != l)
now = 0;
else
now = 1;
else if (a[i][j] != l)
now = 1;
else
now = 0;
}
}
for (int i = 0; i < n; i++)
if ((i + now) % 2 != 0)
a[i][j] = l;
else
a[i][j] = r;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", a[i][j]);
puts("");
}
} else
printf("0\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, ans = -1, st, ed, mid;
cin >> n >> k;
st = 2, ed = k + 1;
while (st <= ed) {
mid = st + (ed - st) / 2;
if ((mid + k) * (k - mid + 1) / 2 - (k - mid) >= n)
ans = k - mid + 1, st = mid + 1;
else
ed = mid - 1;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
const long long int M = 1000000007;
const double pi = acos(-1.0);
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int t;
t = 1;
while (t--) {
long long int n, i;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long int> v1, v2;
for (i = 1; i < n; i += 2) {
v1.push_back(a[i]);
}
for (i = 0; i < n; i += 2) {
v1.push_back(a[i]);
}
v2 = v1;
for (i = 0; i < n; i++) {
v2.push_back(v1[i]);
}
long long int x = (n + 1) / 2, ans = -1, sum = 0;
for (i = 0; i < v2.size(); i++) {
if (i < x) {
sum += v2[i];
ans = max(ans, sum);
} else {
sum += v2[i];
sum -= v2[i - x];
ans = max(ans, sum);
}
}
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, f;
bool a[1007], b[1007];
void read() {
scanf("%d %d", &n, &f);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
a[i] = x;
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
b[i] = x;
}
}
void solve() {
if (!a[1]) {
printf("NO\n");
return;
}
if (a[f]) {
printf("YES\n");
return;
}
for (int i = f; i <= n; i++)
if ((a[i] && b[i] && b[f])) {
printf("YES\n");
return;
}
printf("NO\n");
}
int main() {
read();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, endt, val[200000 + 10], t[200000 + 10];
struct cmp1 {
bool operator()(const int &i, const int &j) {
return t[i] == t[j] ? i < j : t[i] < t[j];
}
};
struct cmp2 {
bool operator()(const int &i, const int &j) {
return t[i] == t[j] ? i > j : t[i] > t[j];
}
};
set<int, cmp1> myset;
set<int, cmp2> myset2;
template <class T>
void Read(T &x) {
char c;
while (c = getchar(), c != EOF)
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
void read() {
Read(n), Read(m), Read(endt);
for (int i = 1; i <= n; i++) Read(val[i]);
for (int i = 1; i <= n; i++) Read(t[i]);
}
void solve() {
int ans = 0, nowv = 0, nowt = 0, cnt = 0, x;
for (int l = 1, r = 1; l <= n; l++) {
while (r <= n) {
if (cnt < m) {
if (nowt + (t[r] + 1) / 2 <= endt) {
myset.insert(r);
nowt += (t[r] + 1) / 2;
nowv += val[r];
cnt++, r++;
} else
break;
} else {
int x = *myset.begin();
if (t[x] / 2 < t[r] / 2) {
if (nowt + t[x] - (t[x] + 1) / 2 + (t[r] + 1) / 2 <= endt) {
nowt += t[x] - (t[x] + 1) / 2 + (t[r] + 1) / 2;
nowv += val[r];
set<int>::iterator iit = myset.find(x);
myset.erase(iit);
myset2.insert(x);
myset.insert(r);
r++;
} else
break;
} else {
if (nowt + t[r] <= endt) {
myset2.insert(r);
nowt += t[r];
nowv += val[r];
r++;
} else
break;
}
}
}
if (l == r) continue;
ans = max(ans, nowv);
set<int>::iterator it = myset.find(l);
if (it == myset.end()) {
nowt -= t[l];
myset2.erase(myset2.find(l));
} else {
nowt -= (t[l] + 1) / 2;
myset.erase(it);
cnt--;
if (!myset2.empty()) {
x = *myset2.begin();
nowt += -t[x] + (t[x] + 1) / 2;
myset2.erase(myset2.begin());
myset.insert(x);
cnt++;
}
}
nowv -= val[l];
}
printf("%d\n", ans);
}
int main() {
read();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20, M = 1 << 18 | 5;
struct state {
int a[20];
bool operator<(const state &b) const {
for (int i = (int)(0); i <= (int)(19); i++)
if (a[i] != b.a[i]) return a[i] < b.a[i];
return 0;
}
} sta[1005];
map<state, int> mp;
int top, n, p, cnt[M];
char tr[N][N];
long long f[M][N], g[N][M];
long long val[1005], h[M];
void dfs(int n, int d, state tmp) {
if (!n) {
sta[++top] = tmp;
mp[tmp] = top;
return;
}
if (n < d) return;
for (; n >= 0; n -= d) {
dfs(n, d + 1, tmp);
tmp.a[d]++;
}
}
void dfss(int n, int d, long long v1, int S) {
if (!n) return val[++p] += v1, void(0);
if (n < d) return;
for (; n >= 0; n -= d) {
dfss(n, d + 1, v1, S);
v1 *= g[d][S];
}
}
int main() {
scanf("%d", &n);
for (int i = (int)(0); i <= (int)(n - 1); i++) scanf("%s", tr[i]);
for (int i = (int)(0); i <= (int)(n - 1); i++)
for (int j = (int)(0); j <= (int)(n - 1); j++) tr[i][j] -= '0';
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
cnt[i] = cnt[i / 2] + (i & 1);
for (int i = (int)(0); i <= (int)(n - 1); i++) f[1 << i][i] = 1;
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
for (int j = (int)(0); j <= (int)(n - 1); j++)
if (i & (1 << j))
for (int k = (int)(0); k <= (int)(n - 1); k++)
if (!(i & (1 << k)))
if (!tr[j][k]) f[i | (1 << k)][k] += f[i][j];
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
for (int j = (int)(0); j <= (int)(n - 1); j++) g[cnt[i]][i] += f[i][j];
for (int s = (int)(0); s <= (int)(n); s++)
for (int d = 1; d < 1 << n; d <<= 1)
for (int i = 0; i < 1 << n; i += d << 1)
for (int j = 0; j < d; j++) g[s][i + j + d] += g[s][i + j];
state tmp;
memset(tmp.a, 0, sizeof(tmp.a));
dfs(n, 1, tmp);
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
p = 0, dfss(n, 1, ((n - cnt[i]) & 1 ? -1 : 1), i);
--n;
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++) {
memset(tmp.a, 0, sizeof(tmp.a));
int l = 0;
for (int j = (int)(0); j <= (int)(n); j++)
if ((i & (1 << j)) || j == n)
++tmp.a[l + 1], l = 0;
else
++l;
h[i] = val[mp[tmp]];
}
for (int d = 1; d < 1 << n; d <<= 1)
for (int i = 0; i < 1 << n; i += (d << 1))
for (int j = 0; j < d; j++) h[i + j + d] -= h[i + j];
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++) printf("%lld ", h[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
priority_queue<pair<int, int> > pq;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x > 0) pq.push(make_pair(x, i + 1));
}
vector<pair<int, int> > res;
while (pq.size() > 1) {
pair<int, int> p1 = pq.top();
pq.pop();
pair<int, int> p2 = pq.top();
pq.pop();
res.push_back(make_pair(p1.second, p2.second));
p1.first--;
p2.first--;
if (p1.first != 0) pq.push(p1);
if (p2.first != 0) pq.push(p2);
}
cout << res.size() << "\n";
for (int i = 0; i < res.size(); i++) {
cout << res[i].first << " " << res[i].second << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 5;
using namespace std;
int a[maxn], b[maxn], c[maxn];
void DFS(int n, int m);
int p;
int main() {
std::ios::sync_with_stdio(false);
memset(c, 0, sizeof(c));
cin >> p;
for (int i = 1; i <= p; i++) {
cin >> a[i] >> b[i];
}
c[1] = 1;
cout << "1 ";
DFS(1, 1);
}
void DFS(int n, int m) {
if (n == p) return;
int x = a[m];
int y = b[m];
if (!c[x] && (a[x] == y || b[x] == y)) {
c[x] = 1;
cout << x << " ";
DFS(n + 1, x);
} else {
c[y] = 1;
cout << y << " ";
DFS(n + 1, y);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
int lcp[N];
void fill_lcp(const string &pat) {
int m = pat.length();
int i = 1, j = 0;
while (i < m) {
if (pat[i] == pat[j]) {
lcp[i++] = ++j;
} else {
if (j)
j = lcp[j - 1];
else
i++;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s, t;
cin >> s >> t;
for (char &c : s) {
if (c == 'N')
c = 'S';
else if (c == 'S')
c = 'N';
else if (c == 'E')
c = 'W';
else
c = 'E';
}
reverse(s.begin(), s.end());
fill_lcp(s + '#' + t);
if (lcp[2 * n - 2])
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
int64_t n, m, k, ans, a[500005];
int64_t power(int64_t a, int64_t p, int64_t m = 1e9 + 7) {
return p ? power(a * a % m, p / 2, m) * (p & 1 ? a : 1) % m : 1;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct DSU {
unordered_map<int, int> par;
int comp_sz = n;
int get(int u) {
if (!par.count(u)) return u;
return par[u] = get(par[u]);
}
void unite(int x, int y) {
int X = get(x), Y = get(y);
if (X == Y) return;
if (rng() % 2)
par[Y] = X;
else
par[X] = Y;
--comp_sz;
}
};
map<int64_t, DSU> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; cin >> a[i++])
;
for (int x, y; m--; mp[a[x] ^ a[y]].unite(x, y)) cin >> x >> y;
for (auto i : mp) (ans += power(2, i.second.comp_sz)) %= md;
cout << (power(2, n) * (power(2, k) - mp.size()) + ans) % md;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void input(long long int n, long long int arr[]) {
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
cin >> arr[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
if (n % m == 0)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
#include <fstream>
#include<chrono>
using namespace std;
using namespace chrono;
#define ll long long
#define db double
#define deb(x) cout<<#x<<": "<<x<<"\n"
#define all(x) x.begin(),x.end()
#define fo(i, n) for(i=0 ; i<n ; i++)
#define Fo(i, k, n) for(i=k ; i<n ; i++)
#define setBits(x) __builtin_popcountll(x)
#define parity(x) __builtin_parity(x)
void solve()
{
int x;cin>>x;
if(x>45)
{
cout<<-1<<endl;
return;
}
int arr[10]={0};
int n=x;
for(int i=9;i>=1;i--)
{
if(n-i>=0)
{
arr[i]++;
n-=i;
}
}
//cout<<"Ans = ";
for(int i=1;i<=9;i++)
{
if(arr[i]==1)
cout<<i;
}
cout<<endl;
}
int32_t main() {
int t;cin>>t;
while(t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAX = 5e5;
const long long int mod = 1e9 + 7;
long long int power[MAX + 1];
long long int c[MAX + 1];
set<long long int> s;
vector<long long int> g[MAX + 1];
map<long long int, vector<long long int>> adj[MAX + 1];
map<long long int, bool> vis[MAX + 1];
map<long long int, long long int> tot;
map<long long int, long long int> comp;
void DFS(long long int v, long long int x) {
vis[v][x] = true;
tot[x]++;
for (auto u : adj[v][x]) {
if (!vis[u][x]) {
DFS(u, x);
}
}
return;
}
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
for (long long int j = 1; j <= n; j++) cin >> c[j];
for (long long int j = 1; j <= m; j++) {
long long int u, v;
cin >> u >> v;
s.insert(c[u] ^ c[v]);
g[v].push_back(u);
g[u].push_back(v);
adj[u][c[u] ^ c[v]].push_back(v);
adj[v][c[u] ^ c[v]].push_back(u);
}
for (long long int v = 1; v <= n; v++) {
for (auto u : g[v]) {
long long int x = c[u] ^ c[v];
if (!vis[v][x]) {
comp[x]++;
DFS(v, x);
}
}
}
long long int ans =
((power[k] - (long long int)s.size() + mod) % mod) * (power[n]);
if (ans >= mod) ans %= mod;
for (auto x : s) {
ans += power[n - tot[x]] * power[comp[x]];
if (ans >= mod) ans %= mod;
}
cout << ans << "\n";
return;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
power[0] = 1;
for (long long int j = 1; j <= MAX; j++) {
power[j] = power[j - 1] * 2;
power[j] %= mod;
}
while (t--) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 33;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(15);
long long n, k;
cin >> n >> k;
string str;
cin >> str;
set<char> unique;
vector<char> v;
for (const auto &item : str) unique.insert(item);
for (const auto &item : unique) v.emplace_back(item);
long long ans = toupper(v[0]) - 'A' + 1;
char last = v[0];
long long cnt = 0;
for (long long i = 1; cnt < k - 1 and i < v.size(); ++i) {
if (v[i] - last >= 2) {
ans += toupper(v[i]) - 'A' + 1;
last = v[i];
cnt++;
}
}
cout << (cnt == k - 1 ? ans : -1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
struct comp {
double x, y;
inline comp operator+(comp b) const { return (comp){x + b.x, y + b.y}; }
inline comp operator-(comp b) const { return (comp){x - b.x, y - b.y}; }
inline comp operator*(comp b) const {
return (comp){x * b.x - y * b.y, x * b.y + y * b.x};
}
inline comp operator*(double c) const { return (comp){x * c, y * c}; }
inline comp operator/(double c) const { return (comp){x / c, y / c}; }
} a[800005], b[800005];
int n, m, k, T, res, r[800005], cnt[800005];
char s[200005], t[200005];
inline void FFT(int n, comp *a, int fla) {
for (int i = 0; i < n; i++)
if (r[i] < i) swap(a[i], a[r[i]]);
for (int d = 1; d < n; d <<= 1) {
comp wn = (comp){cos(pi / d), sin(pi / d) * fla}, w;
for (int i = 0, k; i < n; i += (d << 1))
for (k = 0, w = (comp){1.0, 0.0}; k < d; k++, w = w * wn) {
comp x = a[i + k], y = a[i + k + d] * w;
a[i + k] = x + y, a[i + k + d] = x - y;
}
}
if (fla == -1)
for (int i = 0; i < T; i++) a[i] = a[i] / n;
}
inline void solve(char c) {
for (int i = 0; i < T; i++) a[i] = (comp){0.0, 0.0}, b[i] = (comp){0.0, 0.0};
for (int i = 0, lst = -1e9; i < n; i++) {
if (s[i] == c) lst = i;
if ((i - lst) <= k) a[i] = (comp){1.0, 0};
}
for (int i = n - 1, lst = 1e9; i >= 0; i--) {
if (s[i] == c) lst = i;
if ((lst - i) <= k) a[i] = (comp){1.0, 0};
}
for (int i = 0; i < m; i++)
if (t[i] == c) b[m - i - 1] = (comp){1.0, 0};
FFT(T, a, 1), FFT(T, b, 1);
for (int i = 0; i < T; i++) a[i] = a[i] * b[i];
FFT(T, a, -1);
for (int i = 0; i < n; i++) cnt[i] += (int)(a[i].x + 0.5);
}
signed main() {
scanf("%d%d%d%s%s", &n, &m, &k, s, t), T = 1, r[0] = 0, res = 0;
while (T <= n + m) T <<= 1;
for (int i = 0; i < T; i++)
r[i] = ((r[i >> 1] >> 1) | ((i & 1) ? (T >> 1) : 0));
solve('A'), solve('C'), solve('G'), solve('T');
for (int i = 0; i < n; i++)
if (cnt[i] == m) res++;
return printf("%d\n", res), 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
long long f[1 << 18][101];
string s;
int n, mod, Pow[20];
long long lui(int st, int remain) {
if (st == 0) return remain == 0;
if (f[st][remain] != -1) return f[st][remain];
long long res = 0, cnt = 0;
for (int i = 0; i < n; i++) cnt += (st >> i) & 1;
int dd[12] = {};
for (int i = 0; i < n; i++) {
if ((st >> i) & 1 && dd[s[i] - '0'] == 0) {
if (s[i] != '0' || st != (1 << n) - 1) {
int n_st = st - (1 << i),
n_remain = (remain + (s[i] - '0') * Pow[cnt - 1]) % mod;
res = res + lui(n_st, n_remain);
dd[s[i] - '0'] = 1;
}
}
}
return f[st][remain] = res;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> s >> mod;
n = s.length();
Pow[0] = 1;
for (int i = 1; i <= n; i++) Pow[i] = Pow[i - 1] * 10 % mod;
memset(f, -1, sizeof f);
cout << lui((1 << n) - 1, 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[4];
long long i1, i2, n, cur, ans;
int main() {
cin >> n >> a[0] >> a[1] >> a[2];
sort(a, a + 2);
for (i1 = 0; i1 <= n; i1++)
for (i2 = 0; i2 <= n; i2++)
if ((a[0] * i1) + (a[1] * i2) <= n &&
(n - (a[0] * i1) - (a[1] * i2)) % a[2] == 0) {
cur = i1 + i2 + ((n - (a[0] * i1) - (a[1] * i2)) / a[2]);
if (cur > ans) ans = cur;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, k;
long long m = 1e9 + 9;
long long add(long long a, long long b) {
return ((a % m + b % m) % m + m) % m;
}
long long mul(long long a, long long b) {
return ((a % m * b % m) % m + m) % m;
}
const int sz = 1e5 + 9;
char s[sz];
long long base;
long long modpow(long long b, long long p) {
if (b == 1) return 1;
if (b == 0) return 0;
if (p == 1) return b % m;
if (p == 0) return 1;
long long u = modpow(b, p >> 1);
u = mul(u, u);
if (p & 1) u = mul(u, b);
return u;
}
int main() {
scanf("%I64d %I64d %I64d %I64d", &n, &a, &b, &k);
scanf(" %s", s);
for (int i = 0; i < k; i++) {
long long tmp = mul(modpow(a, n - i), modpow(b, i));
tmp = mul(tmp, (s[i] == '+' ? 1 : -1));
base = add(base, tmp);
}
long long cnt = (n + 1) / k;
long long r = modpow(b, k);
r = mul(r, modpow(modpow(a, k), m - 2));
if (r == 1) {
long long ans = mul(base, cnt);
printf("%I64d", ans);
return 0;
}
long long num = add(1, -modpow(r, cnt));
long long den = modpow(add(1, -r), m - 2);
long long ser = mul(num, den);
long long ans = mul(base, ser);
printf("%I64d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
struct quest {
double prob;
double w;
double prod;
double get(double x) { return prob * x + prod; }
} q[100003];
long long int t;
int n;
double maxw;
bool cmp1(const quest &a, const quest &b) {
return a.prob < b.prob || (a.prob == b.prob && a.w < b.w);
}
bool cmp(double k1, double b1, double k2, double b2, double k3, double b3) {
return (k2 - k1) * (b3 - b1) - (k3 - k1) * (b2 - b1) < 0;
}
struct matrix {
double val[3][3];
matrix operator*(const matrix &y) const {
matrix ans;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
double v = 0;
for (int k = 0; k < 3; ++k) {
v += val[i][k] * y.val[k][j];
}
ans.val[i][j] = v;
}
}
return ans;
}
double getdp(double dpn, double n) const {
return val[0][0] * dpn + val[1][0] * n + val[2][0];
}
};
matrix e;
matrix getm(const quest &q) {
matrix ans;
ans.val[0][0] = 1 - q.prob;
ans.val[1][0] = q.prob * maxw;
ans.val[2][0] = q.prod;
ans.val[0][1] = 0;
ans.val[1][1] = 1;
ans.val[2][1] = 1;
ans.val[0][2] = 0;
ans.val[1][2] = 0;
ans.val[2][2] = 1;
return ans;
}
int main() {
memset(&e, 0, sizeof(e));
for (int i = 0; i < 3; ++i) e.val[i][i] = 1;
scanf("%d%I64d", &n, &t);
for (int i = 0; i < n; ++i) {
double a, b, p;
scanf("%lf%lf%lf", &a, &b, &p);
if (b * p > maxw) maxw = b * p;
q[i].prob = p;
q[i].w = a;
q[i].prod = p * a;
}
std::sort(q, q + n, cmp1);
int j = 1;
for (int i = 1; i < n; ++i) {
while (j >= 2 && !cmp(q[j - 2].prob, q[j - 2].prod, q[j - 1].prob,
q[j - 1].prod, q[i].prob, q[i].prod))
--j;
while (j >= 1 && q[j - 1].prob >= q[i].prob) --j;
q[j++] = q[i];
}
long long int curt = 0;
double curdp = 0;
for (int i = 0; i < j; ++i) {
matrix temp[34];
matrix temp2[34];
temp[0] = getm(q[i]);
temp2[0] = e;
for (int k = 1; k <= 33; ++k) {
if ((curt + (1LL << k)) > t) break;
temp[k] = temp[k - 1] * temp[k - 1];
temp2[k] = temp[k - 1] * temp2[k - 1];
}
for (int k = 33; k >= 0; --k) {
long long int next = curt + (1LL << k) - 1;
if (next + 1 > t) continue;
double nexdp = temp2[k].getdp(curdp, curt);
double x = next * maxw - nexdp;
if (i == j - 1 || q[i].get(x) > q[i + 1].get(x)) {
curdp = temp[k].getdp(curdp, curt);
curt = next + 1;
}
}
}
printf("%f\n", curdp);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long poww(long long a, long long b) {
if (b == 0) return 1;
long long tmp = poww(a, b / 2);
return (b & 1 ? a * tmp * tmp : tmp * tmp);
}
string itos(long long i) {
string s = "";
while (i) {
s += char(i % 10 + '0');
i /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long long stoi(string &s) {
long long tot = 0;
for (int i = (int)s.length() - 1, j = 1; i >= 0; i--, j *= 10) {
tot += j * (s[i] + '0');
}
return tot;
}
int months[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
using namespace std;
void tt() { freopen("test.txt", "r", stdin); }
const int MAX = 1e6 + 10;
int n, m, seed, vmax;
int a[MAX];
int rnd() {
int ret = seed;
seed = (1ll * seed * 7 + 13) % (1000 * 1000 * 1000 + 7);
return ret;
;
}
long long pw(long long num, long long c, long long mod) {
num %= mod;
if (c == 0) {
return 1 % mod;
}
long long x = 1ll * pw(num, c / 2, mod);
return (1ll * x % mod * x % mod * (c & 1 ? num : 1) % mod % mod);
}
map<int, long long> s;
int main() {
cin >> n >> m >> seed >> vmax;
for (int i = 1; i <= n; i++) a[i] = (rnd() % vmax) + 1;
for (int i = 1; i <= n; i++) s.insert({i, a[i]});
for (int i = 1; i <= m; i++) {
int x, y;
int op = (rnd() % 4) + 1;
int l = (rnd() % n) + 1;
int r = (rnd() % n) + 1;
if (l > r) {
swap(l, r);
}
if (op == 3)
x = (rnd() % (r - l + 1)) + 1;
else
x = (rnd() % vmax) + 1;
if (op == 4) y = (rnd() % vmax) + 1;
auto itl = s.upper_bound(l);
--itl;
if (itl->first != l) {
s[l] = itl->second;
++itl;
}
auto itr = s.upper_bound(r + 1);
--itr;
if (itr->first != r + 1) {
s[r + 1] = itr->second;
++itr;
}
if (op == 1) {
while (itl != itr) {
itl->second += x;
itl++;
}
} else if (op == 2) {
while (itl != itr) {
s.erase(itl++);
}
s[l] = x;
} else if (op == 3) {
vector<pair<long long, int> > v;
while (itr != itl) {
int a = itr->first;
itr--;
int b = itr->first;
v.push_back({itr->second, a - b});
}
long long res = 0, cnt = 0;
sort(v.begin(), v.end());
for (auto t : v) {
cnt += t.second;
if (cnt >= x) {
res = t.first;
break;
}
}
cout << res << '\n';
} else if (op == 4) {
vector<pair<long long, int> > v;
while (itr != itl) {
int a = itr->first;
itr--;
int b = itr->first;
v.push_back({itr->second, a - b});
}
long long res = 0;
for (auto t : v) {
res = res + 1ll * pw(t.first, x, y) % y * t.second % y;
res %= y;
}
cout << res << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n;
int a[N];
int last[N];
int t[N * 4];
vector<int> in[N];
vector<int> ord[N];
int ans[N];
int get(int v, int tl, int tr, int val) {
if (t[v] < val) return n + 1;
if (tl == tr) return tl;
int tm = (tl + tr) / 2;
if (val <= t[v + v]) {
return get(v + v, tl, tm, val);
}
val -= t[v + v];
if (t[v + v + 1] < val) return n + 1;
return get(v + v + 1, tm + 1, tr, val);
}
void upd(int v, int tl, int tr, int pos, int add) {
if (tl == tr)
t[v] += add;
else {
int tm = (tl + tr) / 2;
if (pos <= tm)
upd(v + v, tl, tm, pos, add);
else
upd(v + v + 1, tm + 1, tr, pos, add);
t[v] = t[v + v] + t[v + v + 1];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ord[1].push_back(i);
}
for (int i = 1; i <= n; i++) {
int from = 1;
from = last[a[i]] + 1;
last[a[i]] = i;
in[from].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < in[i].size(); j++) {
int x = in[i][j];
upd(1, 1, n, x, 1);
}
for (int j = 0; j < ord[i].size(); j++) {
int x = ord[i][j];
ans[x]++;
int pos = get(1, 1, n, x + 1);
ord[pos].push_back(x);
}
upd(1, 1, n, i, -1);
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << ' ';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
for (int i = 0; i < n; ++i) cin >> a[i];
int dp[n][n];
for (int i = 0; i < n; ++i) dp[i][i] = 1;
for (int i = 0; i < n - 1; ++i) {
if (a[i] == a[i + 1])
dp[i][i + 1] = 1;
else
dp[i][i + 1] = 2;
}
for (int i = 2; i < n; ++i) {
for (int j = 0; j < n - i; ++j) {
dp[j][j + i] = 1 + dp[j + 1][j + i];
dp[j][j + i] = min(dp[j][j + i], dp[j][j + 1] + dp[j + 2][j + i]);
for (int k = j + 2; k < j + i; ++k) {
if (a[j] == a[k])
dp[j][j + i] = min(dp[j][j + i], dp[j + 1][k - 1] + dp[k + 1][j + i]);
}
if (a[j] == a[j + i])
dp[j][j + i] = min(dp[j][j + i], dp[j + 1][j + i - 1]);
}
}
cout << dp[0][n - 1];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> calc(int n, long long m) {
if (n == 0) return make_pair(0, 0);
long long len = 1LL << (n - 1), cnt = 1LL << (2 * n - 2);
pair<long long, long long> pos = calc(n - 1, m % cnt);
long long x = pos.first, y = pos.second;
long long z = m / cnt;
if (z == 0) return make_pair(y, x);
if (z == 1) return make_pair(x, y + len);
if (z == 2) return make_pair(x + len, y + len);
return make_pair(2 * len - y - 1, len - x - 1);
}
int main() {
long long n, m;
cin >> n >> m;
pair<long long, long long> pos = calc(n, m);
long long x = pos.first, y = pos.second;
cout << x << " " << y << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e6;
long long n, m;
long long s[MAX];
long long p[MAX];
long long sz[MAX];
long long find(long long x) {
if (p[x] == x) return x;
return p[x] = find(p[x]);
}
void join(long long a, long long b) {
a = find(a);
b = find(b);
if (a == b) return;
if (rand() & 1) swap(a, b);
p[a] = b;
sz[b] += sz[a];
}
struct edge {
long long u, v, w;
bool operator<(const edge &o) const { return w > o.w; }
} edges[MAX];
long long E;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < (n); i++) cin >> s[i];
for (long long i = 0; i < (n); i++) p[i] = i;
for (long long i = 0; i < (n); i++) sz[i] = 1;
for (long long i = 0; i < (m); i++) {
long long u, v;
cin >> u >> v;
u--, v--;
long long w = min(s[u], s[v]);
edges[E++] = (edge){u, v, w};
}
sort(edges, edges + E);
for (long long i = 0; i < E; i++) {
long long u = edges[i].u;
long long v = edges[i].v;
long long w = edges[i].w;
}
long long sum = 0;
for (long long i = 0; i < E; i++) {
long long u = edges[i].u;
long long v = edges[i].v;
long long w = edges[i].w;
long long a = find(u);
long long b = find(v);
if (a == b) continue;
long long cnt = sz[a] * sz[b] * w;
sum = sum + cnt;
join(a, b);
}
cout << setprecision(10) << fixed << 2LL * sum / (double)(n * (n - 1))
<< '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, siz[100001];
vector<long long> adj[100001];
bool dead[100001];
void dfs(long long u, long long par) {
siz[u] = 1;
for (long long i = 0; i < (long long)adj[u].size(); i++) {
long long v = adj[u][i];
if (v == par || dead[v]) continue;
dfs(v, u);
siz[u] += siz[v];
}
return;
}
vector<long long> cTree[100001];
long long findCentroid(long long u, long long par, long long N) {
for (auto v : adj[u]) {
if (v == par || dead[v]) continue;
if (siz[v] > N / 2) return findCentroid(v, u, N);
}
return u;
}
char ans[100001];
void build(long long prev, long long u, long long N, long long c) {
dfs(u, -1);
long long x = findCentroid(u, -1, N);
ans[x] = (char)c;
dead[x] = 1;
for (auto v : adj[x]) {
if (!dead[v]) build(x, v, N / 2, c + 1);
}
return;
}
void getAns(long long u, long long c, long long p) {
if (c > 90) {
cout << "Impossible!";
exit(0);
}
ans[u] = (char)c;
for (auto v : cTree[u]) {
if (v != p) getAns(v, c + 1, u);
}
return;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, -1);
long long x = findCentroid(1, -1, n);
dead[x] = 1;
ans[x] = 'A';
for (auto u : adj[x]) build(x, u, n / 2, 66);
for (long long i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
string s;
vector<long long> v;
cin >> n;
cin >> s;
int z;
for (long long i = 0; i < n; i++) {
cin >> z;
v.push_back(z);
}
bool col = false;
vector<int> diff;
int x;
int ind = find(v.begin(), v.end(), 'R') - v.end();
for (long long i = ind; i < n - 1; i++) {
if (s[i] == 'R') {
if (s[i + 1] == 'L') {
x = abs(v[i] - v[i + 1]) / 2;
diff.push_back(x);
col = true;
}
}
}
if (col == false)
cout << "-1" << endl;
else
cout << *min_element(diff.begin(), diff.end());
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void ckmax(T& x, T y) {
x = (y > x ? y : x);
}
template <typename T>
inline void ckmin(T& x, T y) {
x = (y < x ? y : x);
}
namespace Fread {
const int SIZE = 1 << 21;
char buf[SIZE], *S, *T;
inline char getchar() {
if (S == T) {
T = (S = buf) + fread(buf, 1, SIZE, stdin);
if (S == T) return '\n';
}
return *S++;
}
} // namespace Fread
namespace Fwrite {
const int SIZE = 1 << 21;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush() {
fwrite(buf, 1, S - buf, stdout);
S = buf;
}
inline void putchar(char c) {
*S++ = c;
if (S == T) flush();
}
struct NTR {
~NTR() { flush(); }
} ztr;
} // namespace Fwrite
namespace Fastio {
struct Reader {
template <typename T>
Reader& operator>>(T& x) {
char c = Fread ::getchar();
T f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = Fread ::getchar();
}
x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + (c - '0');
c = Fread ::getchar();
}
x *= f;
return *this;
}
Reader& operator>>(char& c) {
c = Fread ::getchar();
while (c == '\n' || c == ' ') c = Fread ::getchar();
return *this;
}
Reader& operator>>(char* str) {
int len = 0;
char c = Fread ::getchar();
while (c == '\n' || c == ' ') c = Fread ::getchar();
while (c != '\n' && c != ' ') {
str[len++] = c;
c = Fread ::getchar();
}
str[len] = '\0';
return *this;
}
Reader() {}
} cin;
const char endl = '\n';
struct Writer {
template <typename T>
Writer& operator<<(T x) {
if (x == 0) {
Fwrite ::putchar('0');
return *this;
}
if (x < 0) {
Fwrite ::putchar('-');
x = -x;
}
static int sta[45];
int top = 0;
while (x) {
sta[++top] = x % 10;
x /= 10;
}
while (top) {
Fwrite ::putchar(sta[top] + '0');
--top;
}
return *this;
}
Writer& operator<<(char c) {
Fwrite ::putchar(c);
return *this;
}
Writer& operator<<(char* str) {
int cur = 0;
while (str[cur]) Fwrite ::putchar(str[cur++]);
return *this;
}
Writer& operator<<(const char* str) {
int cur = 0;
while (str[cur]) Fwrite ::putchar(str[cur++]);
return *this;
}
Writer() {}
} cout;
} // namespace Fastio
const int MAXN = 2000;
const int MAXBITS = 2000;
int n;
struct BinaryBigNumber {
bitset<MAXBITS> b;
bool operator!() const { return b.count() == 0; }
BinaryBigNumber operator^(const BinaryBigNumber& rhs) const {
BinaryBigNumber res;
res.b = b ^ rhs.b;
return res;
}
BinaryBigNumber& operator^=(const BinaryBigNumber& rhs) {
*this = ((*this) ^ rhs);
return *this;
}
BinaryBigNumber() {}
};
Fastio ::Reader& operator>>(Fastio ::Reader& is, BinaryBigNumber& item) {
static char s[MAXBITS + 5];
static int t[MAXBITS + 5];
is >> (s + 1);
int len = strlen(s + 1);
reverse(s + 1, s + len + 1);
for (int i = 1; i <= len; ++i) {
t[i] = s[i] - '0';
}
item.b.reset();
int cnt = 0;
while (len) {
unsigned long long x = 0;
for (int i = len; i >= 1; --i) {
x = x * 10 + t[i];
t[i] = x / 16;
x %= 16;
}
for (int i = 0; i < 4; ++i) {
item.b[cnt++] = ((x >> i) & 1);
}
while (len && !t[len]) {
--len;
}
}
return is;
}
struct LinerBase {
BinaryBigNumber base[MAXBITS];
bitset<MAXN> mask[MAXBITS];
bitset<MAXN> insert(BinaryBigNumber x, int idx) {
bitset<MAXN> res;
res.reset();
for (int i = MAXBITS - 1; i >= 0; --i) {
if (x.b[i]) {
if (!base[i]) {
base[i] = x;
res[idx] = 1;
mask[i] = res;
res.reset();
return res;
}
x ^= base[i];
res ^= mask[i];
}
}
return res;
}
LinerBase() {}
};
LinerBase LB;
int main() {
Fastio ::cin >> n;
for (int i = 0; i < n; ++i) {
BinaryBigNumber x;
Fastio ::cin >> x;
bitset<MAXN> b = LB.insert(x, i);
if (!b.count()) {
Fastio ::cout << 0 << Fastio ::endl;
} else {
int cnt = b.count();
Fastio ::cout << cnt << " ";
int cur = 0;
for (int j = 0; j < i; ++j) {
if (b[j]) Fastio ::cout << j << " \n"[++cur == cnt];
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, ans;
int n, k;
cin >> n >> k >> s;
for (int i = 0; i < n; ++i) ans += s[i % k];
if (ans < s)
for (int i = k - 1; ++ans[i] > '9'; i--) ans[i] = '0';
for (int i = 0; i < n; ++i) ans[i] = ans[i % k];
cout << n << endl << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
void umax(int &a, int b) { a = max(a, b); }
void umin(int &a, int b) { a = min(a, b); }
void file() { freopen("a.in", "r", stdin); }
namespace Solver {
int n, m;
int v[111];
double dp[2][111000], s[2][111000];
void solve() {
scanf("%d%d", &n, &m);
if (m == 1) {
puts("1");
return;
}
long long val = 0;
for (int i = 1; i <= n; i++) scanf("%d", &v[i]), val += v[i];
double sum = 0;
dp[0][0] = m - 1;
s[0][0] = m - 1;
for (int i = 1; i <= n * m; i++) s[0][i] = s[0][i - 1];
for (int i = 1; i <= n; i++) {
int now = i & 1, pre = now ^ 1;
memset(dp[now], 0, sizeof dp[now]);
memset(s[now], 0, sizeof s[now]);
for (int j = 1; j <= n * m + m; j++) {
double sum = 0;
sum = s[pre][j - 1] - dp[pre][j - v[i]];
if (j - m - 1 >= 0) sum -= s[pre][j - m - 1];
dp[now][j] = sum / (m - 1);
s[now][j] = dp[now][j];
s[now][j] += s[now][j - 1];
}
}
printf("%.14f\n", s[n & 1][val - 1] + 1);
}
}; // namespace Solver
int main() {
Solver::solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[233];
bool Check() {
int x = 0;
for (int i = 1; i <= n; i++) x += a[i] - 1;
int y;
if (x / (n / 2) == 0)
y = x / (n / 2);
else
y = x / (n / 2) + 1;
if (y & 1) return true;
return false;
}
int main() {
scanf("%d", &n);
int ONE = 0, Min = 0x7fffffff;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (Min > a[i]) Min = a[i], ONE = 0;
if (a[i] == Min) ONE++;
}
if (ONE > n / 2) return printf("Bob"), 0;
return printf("Alice"), 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long Rev[35], C[35][35];
long long powmod(long long x, long long y = 998244353 - 2,
long long p = 998244353) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % 998244353;
x = x * x % 998244353;
y >>= 1;
}
return ans;
}
struct Poly {
long long X[35], L, R;
Poly() { memset(X, 0, sizeof X); }
Poly(long long _1) {
memset(X, 0, sizeof X);
X[0] = _1;
}
long long getval(long long x) {
long long ans = 0;
for (long long nw = 1, i = 0; i < 35; i++, nw = nw * x % 998244353)
ans = (ans + nw * X[i]) % 998244353;
return ans;
}
Poly minus(long long x) {
Poly Ans;
for (long long i = 0; i < 35; i++)
for (long long j = 0, s = 1; j <= i;
j++, s = s * (998244353 - x) % 998244353)
Ans.X[i - j] =
(Ans.X[i - j] + X[i] * C[i][j] % 998244353 * s) % 998244353;
return Ans;
}
Poly intg() {
Poly Ans;
for (long long i = 1; i < 35; i++) Ans.X[i] = X[i - 1] * Rev[i] % 998244353;
Ans.X[0] = 0;
return Ans;
}
Poly operator+(const Poly& A) {
Poly Ans;
for (long long i = 0; i < 35; i++) Ans.X[i] = (X[i] + A.X[i]) % 998244353;
return Ans;
}
Poly operator-(const Poly& A) {
Poly Ans;
for (long long i = 0; i < 35; i++) Ans.X[i] = (X[i] - A.X[i]) % 998244353;
return Ans;
}
void operator/=(const long long& x) {
long long tmp = powmod(x);
for (long long i = 0; i < 35; i++) X[i] = X[i] * tmp % 998244353;
}
};
long long n, K[33];
vector<Poly> S[33];
int main() {
for (long long i = 1; i < 35; i++) Rev[i] = powmod(i);
for (long long i = 0; i < 35; i++)
for (long long j = 0; j <= i; j++)
C[i][j] = !j ? 1 : (C[i - 1][j - 1] + C[i - 1][j]) % 998244353;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
double x;
scanf("%lf", &x);
K[i] = (long long)(x * 1e6 + 0.5);
}
S[1].resize(3);
S[1][0].L = -1000000;
S[1][0].R = 0;
S[1][1].L = 0;
S[1][1].R = min(K[1], 1000000ll);
S[1][1].X[0] = powmod(1000000);
S[1][2].L = min(K[1], 1000000ll);
S[1][2].R = 1e18;
for (long long i = 2; i <= n; i++) {
long long l = 0, r = 1, nw = -1000000;
S[i].resize(1);
S[i][0].L = -1000000;
S[i][0].R = 0;
K[i] = min(K[i - 1] + 1000000, K[i]);
while (l < S[i - 1].size()) {
long long mn = min(S[i - 1][l].R - nw, S[i - 1][r].R - nw - 1000000);
if (nw + mn + 1000000 >= K[i]) mn = K[i] - nw - 1000000;
long long x = nw + 1000000;
Poly X;
X = X + Poly(S[i - 1][l].intg().getval(S[i - 1][l].R)) -
S[i - 1][l].intg().minus(1000000);
X = X + S[i - 1][r].intg().minus(0) -
Poly(S[i - 1][r].intg().getval(S[i - 1][r].L));
for (long long j = l + 1; j < r; j++)
X = X + Poly(S[i - 1][j].intg().getval(S[i - 1][j].R) -
S[i - 1][j].intg().getval(S[i - 1][j].L));
X.L = x;
X.R = x + mn;
if (S[i - 1][l].R == mn + x - 1000000) l++;
if (S[i - 1][r].R == mn + x) r++;
X /= 1000000;
S[i].push_back(X);
if (mn + x == K[i]) break;
nw = mn + nw;
}
Poly X;
X.L = K[i];
X.R = 1e18;
S[i].push_back(X);
}
long long ans = 0;
for (long long i = 1; i + 1 < S[n].size(); i++)
ans = (ans + S[n][i].intg().getval(S[n][i].R) -
S[n][i].intg().getval(S[n][i].L)) %
998244353;
printf("%lld\n", (ans % 998244353 + 998244353) % 998244353);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3 * 105000;
int n, q;
int f[MAXN];
int a[MAXN];
int pos[MAXN];
int l, r, t;
void add(int pos, int x) {
for (; pos <= n; pos = pos | (pos + 1)) f[pos] += x;
}
int sum(int pos) {
int res = 0;
for (; pos > 0; pos = (pos & (pos + 1)) - 1) res += f[pos];
return res;
}
int sum(int l, int r) {
if (l > r) return 0;
return sum(r) - sum(l - 1);
}
void assign(int pos, int x) {
int cur = sum(pos, pos);
add(pos, x - cur);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 1; i < n; i++)
if (pos[i + 1] < pos[i]) add(i, 1);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d %d", &t, &l, &r);
if (t == 1) {
printf("%d\n", sum(l, r - 1) + 1);
} else {
int x = a[l], y = a[r];
swap(a[l], a[r]);
swap(pos[x], pos[y]);
if (x > 1) {
if (pos[x - 1] > pos[x])
assign(x - 1, 1);
else
assign(x - 1, 0);
}
if (x < n) {
if (pos[x] > pos[x + 1])
assign(x, 1);
else
assign(x, 0);
}
if (y > 1) {
if (pos[y - 1] > pos[y])
assign(y - 1, 1);
else
assign(y - 1, 0);
}
if (y < n) {
if (pos[y] > pos[y + 1])
assign(y, 1);
else
assign(y, 0);
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double *a[5001];
int t;
double l(int e, int r) {
if (r > t) return 0;
return a[e][r] + 1;
}
int main() {
int q, w, e, r, d[5000];
double c, v, c1, v1, v3, s[5000];
cin >> q >> t;
for (w = 0; w <= q; w++) a[w] = new double[t + 1];
for (w = 0; w <= t; w++) a[q][w] = 0;
for (w = 0; w < q; w++) {
cin >> s[w] >> d[w];
s[w] /= 100.0;
}
for (w = q - 1; w >= 0; w--) {
a[w][t] = 0;
c = 1 - s[w];
v = s[w];
v3 = 1;
for (e = 1; e < d[w]; e++) v3 *= c;
c1 = 0;
for (e = t - 1; e >= 0; e--) {
c1 *= c;
c1 += (l(w + 1, e + 1) - l(w + 1, e + d[w]) * v3) * v;
a[w][e] = c1 + l(w + 1, e + d[w]) * v3;
}
}
printf("%.7f", a[0][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005], C[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
C[i] = arr[i];
}
sort(C, C + n);
int id1 = 0, id2 = 0;
for (int i = 0; i < n; i++) {
if (C[i] != arr[i]) {
id1 = i;
break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (C[i] != arr[i]) {
id2 = i;
break;
}
}
reverse(arr + id1, arr + id2 + 1);
bool isSorted = 1;
for (int i = 0; i < n; i++) {
if (C[i] != arr[i]) isSorted = 0;
}
if (isSorted) {
cout << "yes" << endl;
cout << id1 + 1 << " " << id2 + 1 << endl;
} else {
puts("no");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <typename T, typename... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <typename T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
template <typename T>
void _W(const vector<T> &x) {
for (auto i = x.cbegin(); i != x.cend(); i++) {
if (i != x.cbegin()) putchar(' ');
_W(*i);
}
}
void W() {}
template <typename T, typename... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
const int N = 1e6 + 10;
struct BIT {
int dat[N];
void ins(int x, int v) {
for (int i = x; i < N; i += i & -i) dat[i] ^= v;
}
int ask(int x) {
int s = 0;
for (int i = x; i; i -= i & -i) s ^= dat[i];
return s;
}
} bit;
int n, a[N], sa[N], m, ql[N], qr[N], sol[N];
vector<int> qv[N];
int main() {
R(n);
for (int i = (1); i <= int(n); i++) R(a[i]);
for (int i = (1); i <= int(n); i++) sa[i] = sa[i - 1] ^ a[i];
R(m);
for (int i = 0; i < int(m); i++) R(ql[i], qr[i]);
for (int i = 0; i < int(m); i++) qv[ql[i]].push_back(i);
map<int, int> nx;
for (int i = n; i >= 1; i--) {
if (nx.count(a[i])) bit.ins(nx[a[i]], a[i]);
nx[a[i]] = i;
bit.ins(i, a[i]);
for (int j : qv[i]) {
int ans = bit.ask(qr[j]);
ans ^= sa[qr[j]] ^ sa[ql[j] - 1];
sol[j] = ans;
}
}
for (int i = 0; i < int(m); i++) W(sol[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 10;
int n, m, k;
int cmd[MAXN][5];
bool x[5005], y[5005];
int gra[5005][5005];
int main() {
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (int i = 1; i <= k; ++i) {
scanf("%d%d%d", &cmd[i][1], &cmd[i][2], &cmd[i][3]);
}
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
memset(gra, 0, sizeof(gra));
for (int i = k; i > 0; --i) {
if (cmd[i][1] == 1 && !x[cmd[i][2]]) {
x[cmd[i][2]] = true;
for (int j = 1; j <= m; ++j) {
if (!gra[cmd[i][2]][j]) gra[cmd[i][2]][j] = cmd[i][3];
}
} else if (cmd[i][1] == 2 && !y[cmd[i][2]]) {
y[cmd[i][2]] = true;
for (int j = 1; j <= n; ++j) {
if (!gra[j][cmd[i][2]]) gra[j][cmd[i][2]] = cmd[i][3];
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
printf("%d%c", gra[i][j], j == m ? '\n' : ' ');
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> x = {1, 1, 0, -1, -1, -1, 0, 1};
vector<int> y = {0, 1, 1, 1, 0, -1, -1, -1};
int n, m;
bool border_i(int x) { return !(x >= 0 && x < n); }
bool border_j(int x) { return !(x >= 0 && x < m); }
void DFS(int vertex_i, int vertex_j, vector<string> &grid,
vector<vector<char>> &used, set<pair<int, int>> &one, bool &flag) {
used[vertex_i][vertex_j] = 1;
for (size_t i = 0; i < 8; ++i) {
int to_i = vertex_i + x[i];
int to_j = vertex_j + y[i];
if (border_i(to_i) || border_j(to_j)) {
flag = false;
continue;
}
if (grid[to_i][to_j] == '1') {
one.insert({to_i, to_j});
continue;
}
if (used[to_i][to_j] == 0) {
DFS(to_i, to_j, grid, used, one, flag);
}
}
}
void DFS1(int vertex_i, int vertex_j, const vector<string> &grid,
vector<vector<char>> &used, set<pair<int, int>> &st, bool &flag) {
used[vertex_i][vertex_j] = 1;
int counter = 0;
for (size_t i = 0; i < 8; i += 2) {
int to_i = vertex_i + x[i];
int to_j = vertex_j + y[i];
if (border_i(to_i) || border_j(to_j)) {
continue;
}
if (grid[to_i][to_j] == '1') {
++counter;
st.insert({to_i, to_j});
if (used[to_i][to_j] == 0) {
DFS1(to_i, to_j, grid, used, st, flag);
}
}
}
flag &= counter == 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
vector<string> grid(n);
for (size_t i = 0; i < n; ++i) {
cin >> grid[i];
}
int answer = 0;
for (size_t i = 0; i + 1 < n; ++i) {
for (size_t j = 0; j + 1 < m; ++j) {
if (grid[i][j] == '1' && grid[i][j + 1] == '1' && grid[i + 1][j] == '1' &&
grid[i + 1][j + 1] == '1') {
answer = 4;
}
}
}
vector<vector<char>> used(n, vector<char>(m, 0));
for (size_t i = 0; i < n; ++i) {
for (size_t j = 0; j < m; ++j) {
if (used[i][j] == 0 && grid[i][j] == '0') {
set<pair<int, int>> arr, pampam;
bool flag = true;
DFS(i, j, grid, used, arr, flag);
if (flag) {
pair<int, int> vertex = *arr.begin(), start = *arr.begin();
pampam.insert(vertex);
while (pampam.size() != arr.size() && flag) {
for (size_t i = 0; i < 10; i += 2) {
if (i == 8) {
flag = false;
break;
}
pair<int, int> point = {vertex.first + x[i],
vertex.second + y[i]};
if (arr.count(point) && !pampam.count(point)) {
pampam.insert(point);
vertex = point;
break;
}
}
}
if (flag) {
for (const auto &element : arr) {
int counter = 0;
int vertex_i = element.first;
int vertex_j = element.second;
for (size_t i = 0; i < 8; i += 2) {
int to_i = vertex_i + x[i];
int to_j = vertex_j + y[i];
if (border_i(to_i) || border_j(to_j)) {
continue;
}
if (arr.count({to_i, to_j})) {
counter++;
}
}
flag &= counter == 2;
}
for (size_t i = 0; i < 10; i += 2) {
if (i == 8) {
flag = false;
break;
}
pair<int, int> point = {vertex.first + x[i],
vertex.second + y[i]};
if (point == start) {
break;
}
}
if (flag) {
answer = max(answer, (int)arr.size());
}
}
}
}
}
}
cout << answer << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, val[1000006], a, b;
long long ans = 10000000070000007, dp[1000006][3];
vector<int> allP;
void extract(int x) {
int cur = 1;
while (++cur <= sqrt(x))
if (x % cur == 0) {
allP.push_back(cur);
while (x % cur == 0) x /= cur;
}
if (x != 1) allP.push_back(x);
}
void setup() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) cin >> val[i];
extract(val[1]), extract(val[1] - 1), extract(val[1] + 1);
extract(val[n]), extract(val[n] - 1), extract(val[n] + 1);
sort(allP.begin(), allP.end());
}
long long dping(int p) {
for (int i = 1; i <= n; i++) {
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
if (val[i] % p) {
if ((val[i] - 1) % p && (val[i] + 1) % p)
dp[i][0] = dp[i][2] = 10000000070000007;
else {
dp[i][0] = dp[i - 1][0] + b;
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + b;
}
} else {
dp[i][0] = dp[i - 1][0];
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]);
}
}
long long re = 10000000070000007;
for (int i = 0; i <= 2; i++) re = min(re, dp[n][i]);
return re;
}
void xuly() {
for (int i = 0; i <= int(allP.size()) - 1; i++)
if (i == 0 || allP[i] != allP[i - 1]) ans = min(ans, dping(allP[i]));
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
setup();
xuly();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
long long int rng;
cin >> rng;
sort(a, a + n);
long long int mxn = -1;
for (long long int i = 0; i < n; i++) {
long long int x = a[i] + rng;
long long int l = -1;
long long int r = n;
while (r > l + 1) {
long long int m = (r + l) / 2;
if (a[m] <= x) {
l = m;
} else {
r = m;
}
}
long long int cnt = (r - i);
mxn = max(mxn, cnt);
}
cout << mxn << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
long long n, m, l, r, t, a[200000], b, prevb;
long long i, j, k;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
void solution() {
cin >> n;
;
if (n == 1) {
cin >> b;
;
cout << 1 << "\n";
;
} else {
n--;
ans = 0;
cin >> prevb;
;
for (i = 0; i < n; i++) {
cin >> b;
a[i] = abs(prevb - b);
prevb = b;
}
i = 0;
while ((a[i] == 1) && (i < n)) {
i++;
}
if (i < n) {
t = 2;
m = a[i];
} else {
t = 1;
}
for (i++; i < n; i++) {
m = gcd(m, a[i]);
if (m == 1) {
if (t > ans) {
ans = t;
}
while ((a[i] == 1) && (i < n)) {
i++;
}
if (i < n) {
t = 2;
m = a[i];
} else {
t = 1;
break;
}
l = gcd(m, a[i - 1]);
for (j = i - 2; l != 1; j--) {
m = l;
l = gcd(m, a[j]);
t++;
}
} else {
t++;
}
}
if (t > ans) {
ans = t;
}
cout << ans << "\n";
;
}
}
int main() {
ios::sync_with_stdio(false);
long long ttt;
cin >> ttt;
;
while (ttt--) {
solution();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *r) -> decltype(cerr << *r);
template <class c>
char dud(...);
struct muu {
template <class c>
muu &operator<<(const c &) {
return *this;
}
};
using pii = pair<int, int>;
using ld = long double;
using ll = long long;
const int z = 4 * 1024 * 256;
int _drzewo[2][z * 2 + 7], _sp[2][z * 2 + 7];
void spychaj(int *drzewo, int *sp, int v) {
drzewo[v * 2] += sp[v];
drzewo[v * 2 + 1] += sp[v];
sp[v * 2] += sp[v];
sp[v * 2 + 1] += sp[v];
sp[v] = 0;
}
void wrzuc(int *drzewo, int *sp, int ll, int rr, int war, int v = 1, int l = 0,
int r = z - 1) {
if (r < ll || rr < l) return;
if (ll <= l && r <= rr) {
drzewo[v] += war;
sp[v] += war;
return;
}
spychaj(drzewo, sp, v);
int sr = (l + r) / 2;
wrzuc(drzewo, sp, ll, rr, war, v * 2, l, sr);
wrzuc(drzewo, sp, ll, rr, war, v * 2 + 1, sr + 1, r);
drzewo[v] = max(drzewo[v * 2], drzewo[v * 2 + 1]);
}
int czytaj(int *drzewo, int *sp, int ll, int rr, int v = 1, int l = 0,
int r = z - 1) {
if (r < ll || rr < l) return 0;
if (ll <= l && r <= rr) return drzewo[v];
spychaj(drzewo, sp, v);
int sr = (l + r) / 2;
return max(czytaj(drzewo, sp, ll, rr, v * 2, l, sr),
czytaj(drzewo, sp, ll, rr, v * 2 + 1, sr + 1, r));
}
int main() {
int N;
scanf("%d", &N);
vector<pair<pii, int>> v;
map<int, int> skala;
for (int i = 0; i < N; i++) {
int l, r, t;
scanf("%d%d%d", &l, &r, &t);
skala[l] = 0;
skala[r] = 0;
v.push_back({{l, r}, t});
}
sort(v.begin(), v.end(),
[](pair<pii, int> const &a, pair<pii, int> const &b) {
return a.first.second < b.first.second;
});
int zeit = 0;
for (auto &it : skala) it.second = ++zeit;
int maxi = 0;
for (auto it : v) {
int l = skala[it.first.first], r = skala[it.first.second],
t = it.second - 1;
muu() << __FUNCTION__ << "#" << 100 << ": "
<< "["
"l"
": "
<< (l)
<< "] "
"["
"r"
": "
<< (r)
<< "] "
"["
"t"
": "
<< (t) << "] ";
wrzuc(_drzewo[t], _sp[t], 0, l - 1, 1);
int hmm = czytaj(_drzewo[t], _sp[t], 0, l - 1);
int hmm2 = czytaj(_drzewo[!t], _sp[!t], r, r);
muu() << __FUNCTION__ << "#" << 105 << ": "
<< "["
"hmm"
": "
<< (hmm)
<< "] "
"["
"hmm2"
": "
<< (hmm2) << "] ";
maxi = max(maxi, hmm);
if (hmm2 < hmm) wrzuc(_drzewo[!t], _sp[!t], r, r, hmm - hmm2);
}
printf("%d", maxi);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int vet[123456];
using namespace std;
int main() {
int n, k;
scanf("%d %d", &n, &k);
int vez = k;
int ult = -100000000;
vet[0] = 1;
for (int i = 1; i < n; i++) {
if (vez) {
if (i % 2) {
vet[i] = vet[i - 1] + vez;
} else {
vet[i] = vet[i - 1] - vez;
}
--vez;
} else {
if (ult == -100000000) {
vet[i] = vet[1] + 1;
ult = 2;
} else
vet[i] = vet[i - 1] + 1;
}
}
for (int i = 0; i < n; i++) {
printf("%d ", vet[i]);
}
puts("");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, m, n, v, w, x[100005], y[100005];
int main() {
cin >> n >> m;
for (v = w = n; m--;) {
cin >> a >> b;
v -= !x[a]++;
w -= !y[b]++;
cout << v * w << ' ';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, t = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * t;
}
const int P = 998244353;
const int N = 55;
int n, m, cnt, tot, C[N][N], dp[N][N], f[N], g[N];
long long p[N], d[N];
int Mod(int x) { return x >= P ? x - P : x; }
int Ksm(int x, int k) {
int res = 1;
while (k) {
if (k & 1) res = 1ll * res * x % P;
x = 1ll * x * x % P, k >>= 1;
}
return res;
}
void Ins(long long x) {
for (int i = m - 1; i >= 0; i--)
if (x >> i & 1) {
if (!p[i]) {
p[i] = x, cnt++;
return;
}
x ^= p[i];
}
}
void DFS1(int k, long long S) {
if (k == tot) {
g[__builtin_popcountll(S)]++;
return;
}
DFS1(k + 1, S), DFS1(k + 1, S ^ p[k]);
}
void DFS2(int k, long long S) {
if (k == tot) {
f[__builtin_popcountll(S)]++;
return;
}
DFS2(k + 1, S), DFS2(k + 1, S ^ d[k]);
}
int main() {
n = read(), m = read();
for (int i = 0; i <= m; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = Mod(C[i - 1][j - 1] + C[i - 1][j]);
}
for (int i = 1; i <= n; i++) Ins(read());
if (cnt <= 26) {
for (int i = 0; i < m; i++)
if (p[i]) p[tot++] = p[i];
DFS1(0, 0);
} else {
for (int i = 0; i < m; i++)
for (int j = i - 1; j >= 0; j--)
if (p[i] >> j & 1) p[i] ^= p[j];
for (int i = 0; i < m; i++)
if (!p[i]) {
for (int j = 0; j < m; j++)
if (p[j] >> i & 1) d[tot] |= (1ll << j);
d[tot++] |= (1ll << i);
}
for (int c = 0; c <= m; c++)
for (int i = 0; i <= m; i++)
for (int k = 0; k <= min(m, i); k++) {
int t = 1ll * (k & 1 ? P - 1 : 1) * C[i][k] % P * C[m - i][c - k] % P;
dp[c][i] = Mod(dp[c][i] + t);
}
DFS2(0, 0);
for (int c = 0; c <= m; c++)
for (int i = 0; i <= m; i++) g[c] = Mod(g[c] + 1ll * f[i] * dp[c][i] % P);
for (int c = 0; c <= m; c++)
g[c] = (1ll << cnt) % P * Ksm((1ll << m) % P, P - 2) % P * g[c] % P;
}
for (int c = 0; c <= m; c++) cout << 1ll * g[c] * Ksm(2, n - cnt) % P << ' ';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[105], b[105], n0;
string n, m;
void StringToInt(const string &s, int *c) {
for (int i = 0; i < s.size(); i++) c[i] = s[i] - '0';
}
int main() {
cin >> n >> m;
if (n.size() != m.size()) {
printf("WRONG_ANSWER");
return 0;
}
StringToInt(n, a);
StringToInt(m, b);
sort(a, a + n.size());
for (int i = 0; i < n.size(); i++) {
if (a[i] != 0) {
int tmp = a[i];
a[i] = a[0];
a[0] = tmp;
break;
}
}
for (int i = 0; i < n.size(); i++) {
if (a[i] != b[i]) {
printf("WRONG_ANSWER");
return 0;
}
}
printf("OK");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 100;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b, c, i, j, k, q, p, x, y, ct, ct1, m, l, r, x1, y1, h, sum1, in, z,
mid, n, mx;
char ch;
double d;
string str1, str2, str;
bool bl, bl1;
int t, cs = 1;
cin >> t;
while (t--) {
cin >> a >> b >> c;
cout << max({a, b, c}) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300010;
const int MAXK = 1000010;
int n, k;
int a[MAXN], pref[MAXN], suff[MAXN];
pair<int, int> seg[4 * MAXN];
vector<int> pos[2][MAXK];
vector<pair<int, int> > Query[2][MAXK];
void upd(int pos, int bg, int ed, int id, int val) {
if (bg == ed) {
seg[pos] = make_pair(val, id);
return;
}
int mid = (bg + ed) >> 1, l = 2 * pos, r = 2 * pos + 1;
if (id <= mid)
upd(l, bg, mid, id, val);
else
upd(r, mid + 1, ed, id, val);
seg[pos] = max(seg[l], seg[r]);
}
pair<int, int> qry(int pos, int bg, int ed, int p, int q) {
if (q < p || q < bg || ed < p) return make_pair(0, 0);
if (p <= bg && ed <= q) return seg[pos];
int mid = (bg + ed) >> 1, l = 2 * pos, r = 2 * pos + 1;
return max(qry(l, bg, mid, p, q), qry(r, mid + 1, ed, p, q));
}
void DivideAndConquer(int bg, int ed) {
if (ed <= bg) return;
int mid = qry(1, 1, n, bg, ed).second, x = 0;
if (mid - bg <= ed - mid) {
for (int i = mid - 1; i >= bg; i--) {
x = (x + a[i]) % k;
int y = (k - x) % k;
Query[0][mid + 1].push_back(make_pair(ed, (y + pref[mid]) % k));
}
} else {
for (int i = mid + 1; i <= ed; i++) {
x = (x + a[i]) % k;
int y = (k - x) % k;
Query[1][bg].push_back(make_pair(mid - 1, (y + suff[mid]) % k));
}
}
Query[0][mid + 1].push_back(make_pair(ed, pref[mid]));
Query[1][bg].push_back(make_pair(mid - 1, suff[mid]));
DivideAndConquer(bg, mid - 1);
DivideAndConquer(mid + 1, ed);
}
void seeArrays() {
printf("\na : ");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\np : ");
for (int i = 1; i <= n; i++) printf("%d ", pref[i]);
printf("\ns : ");
for (int i = 1; i <= n; i++) printf("%d ", suff[i]);
printf("\n");
}
void seeQueries() {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)Query[0][i].size(); j++) {
int bg = i, ed = Query[0][i][j].first, x = Query[0][i][j].second;
printf("In the interval [%d, %d] find prefix of %d : ", bg, ed, x);
int l = lower_bound(pos[0][x].begin(), pos[0][x].end(), bg) -
pos[0][x].begin();
int r = upper_bound(pos[0][x].begin(), pos[0][x].end(), ed) -
pos[0][x].begin();
printf("found %d elements\n", r - l);
}
for (int j = 0; j < (int)Query[1][i].size(); j++) {
int bg = i, ed = Query[1][i][j].first, x = Query[1][i][j].second;
printf("In the interval [%d, %d] find suffix of %d : ", bg, ed, x);
int l = lower_bound(pos[1][x].begin(), pos[1][x].end(), bg) -
pos[1][x].begin();
int r = upper_bound(pos[1][x].begin(), pos[1][x].end(), ed) -
pos[1][x].begin();
l--, r--;
printf("found %d elements\n", r - l);
}
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
upd(1, 1, n, i, a[i]);
a[i] %= k;
}
for (int i = 1; i <= n; i++) pref[i] = (pref[i - 1] + a[i]) % k;
for (int i = n; i > 0; i--) suff[i] = (suff[i + 1] + a[i]) % k;
for (int i = 1; i <= n; i++) {
pos[0][pref[i]].push_back(i);
pos[1][suff[i]].push_back(i);
}
DivideAndConquer(1, n);
long long int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)Query[0][i].size(); j++) {
int bg = i, ed = Query[0][i][j].first, x = Query[0][i][j].second;
int l = lower_bound(pos[0][x].begin(), pos[0][x].end(), bg) -
pos[0][x].begin();
int r = upper_bound(pos[0][x].begin(), pos[0][x].end(), ed) -
pos[0][x].begin();
ans += r - l;
}
for (int j = 0; j < (int)Query[1][i].size(); j++) {
int bg = i, ed = Query[1][i][j].first, x = Query[1][i][j].second;
int l = lower_bound(pos[1][x].begin(), pos[1][x].end(), bg) -
pos[1][x].begin();
int r = upper_bound(pos[1][x].begin(), pos[1][x].end(), ed) -
pos[1][x].begin();
l--, r--;
ans += r - l;
}
}
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int A[1005];
vector<pair<int, int> > V;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
if (n == 1) {
cout << "no";
return 0;
}
for (int i = 1; i < n; i++)
V.push_back(make_pair(min(A[i], A[i - 1]), max(A[i], A[i - 1])));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (V[i].first < V[j].first && V[i].second < V[j].second &&
V[j].first < V[i].second) {
cout << "yes";
return 0;
}
}
}
cout << "no";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 1e6 + 17;
const int mod = 1e9 + 7;
int amount[ms];
int xxx[] = {1, -1, 0, 0};
int yyy[] = {0, 0, 1, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
int x = mod, b = -12;
vector<int> v(t, 0);
for (int i = 0; i < t; ++i) {
int x;
cin >> x;
++amount[x];
b = max(b, x);
v[i] = x;
}
sort(v.begin(), v.end());
for (int i = 1; i * i <= t; ++i) {
if (amount[i] != i * 4) {
x = i;
break;
}
}
for (int i = 1; i <= t; ++i) {
if (t % i == 0) {
int temp_n = i, temp_m = t / temp_n;
int temp_y = temp_m + temp_n - b - x;
if (temp_y > 0 && x <= temp_n && temp_y <= temp_m) {
vector<vector<bool> > used(temp_n + 1, vector<bool>(temp_m + 1, 0));
vector<vector<int> > val(temp_n + 1, vector<int>(temp_m + 1, 0));
vector<int> temp_v;
temp_v.push_back(0);
deque<pair<int, int> > bfs;
bfs.push_back(make_pair(x, temp_y));
used[x][temp_y] = true;
while (!bfs.empty()) {
pair<int, int> tt = bfs.front();
bfs.pop_front();
for (int i = 0; i < 4; ++i) {
int xx = tt.first + xxx[i];
int yy = tt.second + yyy[i];
if (xx >= 1 && yy >= 1 && xx <= temp_n && yy <= temp_m &&
!used[xx][yy]) {
used[xx][yy] = true;
val[xx][yy] = val[tt.first][tt.second] + 1;
bfs.push_back(make_pair(xx, yy));
temp_v.push_back(val[xx][yy]);
}
}
}
bool OK = true;
for (int i = 0; i < t; ++i) {
if (temp_v[i] != v[i]) OK = false;
}
if (OK) {
cout << temp_n << ' ' << temp_m << '\n';
cout << x << ' ' << temp_y << '\n';
return 0;
}
}
}
}
cout << -1 << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void one();
int main() {
fastio();
int t = 1;
for (int i = 0; i < t; ++i) {
one();
}
return 0;
}
void one() {
int n;
cin >> n;
vector<int> v(n);
vector<int> par(n);
vector<int> ch(n);
vector<int> lt(n, INT_MAX);
for (int i = 0; i < n; ++i) {
cin >> v[i];
par[i] = i;
}
vector<int> s = {};
for (int i = 0; i < n; ++i) {
while (!s.empty() && v[s.back()] < v[i]) {
s.pop_back();
}
if (s.empty()) {
s.push_back(i);
continue;
}
if (v[i] < v[s.back()]) {
while (!(lt[s.back()] == INT_MAX || ch[s.back()] < lt[s.back()])) {
s.pop_back();
}
lt[i] = ++ch[s.back()];
s.push_back(i);
}
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (lt[i] == INT_MAX) continue;
cnt = max(cnt, lt[i]);
}
cout << cnt << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long, vector<long long>> ms;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
long long arr[n + 2];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
if (n <= 1000) {
long long ans = 1;
for (long long i = 0; i < n; i++) {
long long as = 1;
for (long long j = i + 1; j < n; j++) {
as *= abs(arr[j] - arr[i]) % m;
as %= m;
}
ans *= as % m;
ans %= m;
}
cout << ans << "\n";
} else {
cout << "0"
<< "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
cout << b << " " << c << " " << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, m, h, j;
cin >> n >> m >> h;
vector<int> a(m), b(n);
vector<vector<int> > c(n, vector<int>(m));
vector<vector<int> > d(n, vector<int>(m));
for (i = 0; i < m; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> c[i][j];
if (c[i][j]) d[i][j] = min(a[j], b[i]);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cout << d[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T next_int() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return p * x;
}
string next_token() {
char ch;
string ans = "";
do {
ch = getchar();
} while (ch <= ' ');
while (ch > ' ') {
ans += ch;
ch = getchar();
}
return ans;
}
const long long INF = (long long)1e18;
const int INFINT = (int)1e9 + 227 + 1;
const int MAXN = (int)2e5 + 227 + 1;
const int MOD = (int)1e9 + 7;
const long double EPS = 1e-7;
long long bin_pow(long long a, long long b) {
if (!b) return 1;
long long ans = bin_pow(a, b / 2);
ans = ans * ans;
if (b % 2) ans = ans * a;
return ans;
}
struct bor {
struct node {
node() {
link[0] = link[1] = -1;
sum = k = 0;
}
long long sum;
int link[2];
int k;
};
bor() { t.push_back(node()); }
vector<node> t;
void add(int a) {
int v = 0;
for (int i = 29; i >= 0; i--) {
bool to = (1 << i) & a;
t[v].sum += a;
t[v].k++;
if (t[v].link[to] == -1) {
t[v].link[to] = t.size();
t.push_back(node());
}
v = t[v].link[to];
}
t[v].k++;
t[v].sum += a;
}
void del(int a) {
int v = 0;
for (int i = 29; i >= 0; i--) {
bool to = (1 << i) & a;
t[v].sum -= a;
t[v].k--;
v = t[v].link[to];
}
t[v].k--;
t[v].sum -= a;
}
pair<int, long long> get(long long a) {
if (a > (long long)1e9) return make_pair(t[0].k, t[0].sum);
int v = 0;
pair<int, long long> ans = make_pair(0, 0);
for (int i = 29; i >= 0; i--) {
bool to = (1 << i) & a;
if (to == 1) {
if (t[v].link[0] != -1) {
ans.second += t[t[v].link[0]].sum;
ans.first += t[t[v].link[0]].k;
}
}
if (t[v].link[to] == -1) {
t[v].link[to] = t.size();
t.push_back(node());
}
v = t[v].link[to];
}
ans.second += t[v].sum;
ans.first += t[v].k;
return ans;
}
};
bor t;
long double f(long double i) {
pair<long double, long double> temp = t.get((long long)(i + EPS));
return temp.first * i - temp.second;
}
int a[MAXN];
int main() {
int n = next_int<int>();
int m = next_int<int>();
for (int i = 0; i < n; i++) {
a[i] = next_int<int>();
t.add(a[i]);
}
bool ok = (n == 1 && m == 100000);
int number = 0;
while (m--) {
int type = next_int<int>();
number++;
if (type == 1) {
int p = next_int<int>() - 1;
int x = next_int<int>();
t.del(a[p]);
a[p] = x;
t.add(a[p]);
} else {
long long c = next_int<long long>();
long double l = 0;
long double r = 1e15 + 1e5;
for (int it = 0; it < 80; it++) {
long double C = (l + r) / 2;
if (f(C) < c) {
l = C;
} else {
r = C;
}
}
if (!ok)
cout << setprecision(20) << fixed << l << "\n";
else
cout << fixed << a[0] + c << "\n";
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[60] = {0};
void filldp() {
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i < 60; i++) {
dp[i] = 1;
}
for (int i = 2; i < 60; i++) {
if (dp[i] == 1) {
for (int p = i * i; p < 60; p += i) {
dp[p] = 0;
}
}
}
}
bool isprime(int n) { return dp[n]; }
bool isafter(int x, int y) {
for (int i = x + 1; i < y; i++) {
if (dp[i] == 1) return false;
}
return true;
}
int main() {
filldp();
int x, y;
cin >> x >> y;
if (isprime(x) && isprime(y) && isafter(x, y)) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[2000000];
int y[2000000];
int u[2000000];
int pr[2000000];
int next_[2000000];
int d[2000000];
priority_queue<pair<int, int> > q;
int ne[2000000];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &y[i], &x[i]);
next_[i] = pr[x[i]];
pr[x[i]] = i;
ne[y[i]]++;
}
for (int i = 1; i <= n; i++) d[i] = 1000000000;
int s, t;
scanf("%d%d", &s, &t);
d[t] = 0;
q.push(make_pair(0, t));
while (!q.empty()) {
int v = q.top().second;
q.pop();
if (u[v] == 0) {
u[v] = 1;
int i = pr[v];
while (i > 0) {
int c;
if (ne[y[i]] == 1)
c = 0;
else
c = 1;
if (d[y[i]] > d[v] + c) {
d[y[i]] = d[v] + c;
q.push(make_pair(-d[y[i]], y[i]));
}
ne[y[i]]--;
i = next_[i];
}
}
}
int ans = 0;
ans = d[s];
if (ans > 10000000) ans = -1;
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
int const INF = 1e9;
using namespace std;
const unsigned long long int mod = 1e9 + 9;
int main() {
int n;
cin >> n;
string s;
cin >> s;
n = s.size();
map<char, int> mt;
for (int i(0); i < n; i++) {
mt[s[i]]++;
}
int nch(0);
string tmp;
vector<char> res;
bool f1 = 0;
for (auto it : mt) {
for (int i(0); i < it.second / 2; i++) {
tmp.push_back(it.first);
f1 = 1;
}
if (it.second & 1) {
res.push_back(it.first);
nch++;
}
}
if (f1 == 1 && nch == 0) {
cout << "1\n";
cout << tmp;
for (int i(tmp.size() - 1); i >= 0; i--) printf("%c", tmp[i]);
return 0;
}
while (n % nch != 0 || ((n - nch) / nch) % 2 != 0 || (n / nch) % 2 == 0) {
if (tmp.size()) {
res.push_back(tmp[tmp.size() - 1]);
res.push_back(tmp[tmp.size() - 1]);
nch += 2;
tmp.pop_back();
}
}
if (n % nch != 0 || ((n - nch) / nch) % 2 != 0 || (n / nch) % 2 == 0) {
cout << s.size() << endl;
for (auto it : s) cout << it << " ";
return 0;
}
vector<string> ANS(nch);
int len = n / nch;
int index(0);
for (int i(0); i < nch; i++) {
string L;
for (int j(0); j < len / 2; j++) L.push_back(tmp[index]), index++;
ANS[i] = L;
ANS[i].push_back(res[i]);
for (int j(L.size() - 1); j >= 0; j--) ANS[i].push_back(L[j]);
}
bool check(0);
for (int i(0); i < ANS.size(); i++) {
if (ANS[i].size() != n / nch) {
check = 1;
}
}
if (check) {
if (n % nch != 0 || ((n - nch) / nch) % 2 != 0 || (n / nch) % 2 == 0) {
cout << s.size() << endl;
for (auto it : s) cout << it << " ";
return 0;
}
}
printf("%d\n", ANS.size());
for (int i(0); i < ANS.size(); i++) {
cout << ANS[i];
printf(" ");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000;
int a[N], dp[N];
int main() {
int n, m, ans = 0;
double t;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i] >> t;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++)
if (a[j] <= a[i]) dp[i] = max(dp[j], dp[i]);
dp[i]++;
}
for (int i = 0; i < n; i++) ans = max(dp[i], ans);
cout << n - ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int inp() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum;
}
int s[5010], f[5010], h[5010], d[5010], n, m;
int sum[5010][5010], l[5010], r[5010], cnt1[5010], cnt2[5010], cc;
long long solve(int lb, int rb) {
memset(cnt1, 0, sizeof(cnt1));
memset(cnt2, 0, sizeof(cnt2));
for (int j = 1; j <= m; j++) {
if (l[j] <= lb && r[j] >= rb)
cnt2[f[j]]++;
else if (l[j] <= lb || r[j] >= rb)
cnt1[f[j]]++;
}
cc = 0;
long long cnt = 1;
for (int j = 1; j <= n; j++) {
if (cnt2[j] && (cnt1[j] + cnt2[j] > 1)) {
cnt *= (cnt2[j] * (cnt2[j] - 1) + cnt2[j] * cnt1[j]);
cnt %= 1000000007;
cc += 2;
} else if (cnt2[j] + cnt1[j]) {
cnt *= ((cnt2[j] << 1) + cnt1[j]);
cnt %= 1000000007;
cc++;
}
}
return cnt;
}
int main() {
n = inp();
m = inp();
for (int i = 1; i <= n; i++) s[i] = inp();
for (int i = 1; i <= m; i++) {
f[i] = inp();
h[i] = inp();
}
for (int i = 1; i <= m; i++) {
l[i] = 1;
int sum = 0;
while (sum < h[i] && l[i] <= n + 1) {
sum += (f[i] == s[l[i]]);
l[i]++;
}
l[i]--;
r[i] = n;
sum = 0;
while (sum < h[i] && r[i] >= 0) {
sum += (f[i] == s[r[i]]);
r[i]--;
}
r[i]++;
}
int ans = 0;
long long ans2 = 0;
for (int i = 0; i <= n; i++) {
memset(cnt1, 0, sizeof(cnt1));
memset(cnt2, 0, sizeof(cnt2));
for (int j = 1; j <= m; j++) {
if (l[j] <= i && r[j] > i)
cnt2[f[j]]++;
else if (l[j] <= i || r[j] > i)
cnt1[f[j]]++;
}
long long cnt = solve(i, i + 1);
int sum = cc;
solve(i - 1, i + 1);
if (sum == cc && i > 0) {
cnt -= solve(i - 1, i + 1);
cnt += 1000000007;
cnt %= 1000000007;
}
if (sum > ans) {
ans = sum;
ans2 = cnt;
} else if (sum == ans) {
ans2 += cnt;
ans2 %= 1000000007;
}
}
printf("%d %lld\n", ans, ans2);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, xx, yy;
cin >> n >> m >> xx >> yy;
cout << xx << " " << yy << '\n';
for (int i = 1; i <= m; i++)
if (i != yy) cout << xx << " " << i << '\n';
bool rev = true;
for (int i = 1; i <= n; i++)
if (i != xx) {
if (rev) {
for (int j = m; j >= 1; j--) cout << i << " " << j << '\n';
rev = false;
} else {
for (int j = 1; j <= m; j++) cout << i << " " << j << '\n';
rev = true;
}
}
}
int main() {
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const MaxSize = 200010;
int n, p[MaxSize];
bool visited[MaxSize];
int calcCycle() {
int ans = 0;
for (int i = int(1); i <= int(n); i++) {
if (visited[i]) continue;
ans++;
visited[i] = true;
int cStart = i;
int cNext = p[cStart];
while (cNext != cStart) {
visited[cNext] = true;
cNext = p[cNext];
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = int(1); i <= int(n); i++) cin >> p[i];
int nR = 0;
for (int i = int(1); i <= int(n); i++) {
int bi;
cin >> bi;
if (bi) nR++;
}
int nc = calcCycle();
int total = 0;
if (nc > 1) total += nc;
if (nR % 2 == 0) total++;
cout << total << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
template <class T>
inline T isqrt(T k) {
T r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
template <class T>
inline T icbrt(T k) {
T r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
const int maxn = 100000 + 10;
int n, m;
int p10[maxn];
int ip10[maxn];
pair<int, int> euclid(int a, int b) {
if (b == 0) return make_pair(1, 0);
pair<int, int> r = euclid(b, a % b);
return make_pair(r.second, r.first - a / b * r.second);
}
int inverse(int a, int m) {
pair<int, int> r = euclid(a, m);
return (r.first % m + m) % m;
}
struct CentroidTree {
struct Info {
int d, x, y;
Info() : d(0), x(0), y(0) {}
Info(int d, int x, int y) : d(d), x(x), y(y) {}
Info(const Info& rhs) : d(rhs.d), x(rhs.x), y(rhs.y) {}
Info operator+(const int& w) const {
Info res(d + 1, x, y);
res.x = mult(res.x, 10, m);
addmod(res.x, w, m);
addmod(res.y, mult(w, p10[d], m), m);
return res;
}
};
static const int maxn = 100000 + 10;
static const int logn = 20;
int n, rt;
vector<pair<int, int> > adj[maxn];
int size[maxn];
int rem[maxn];
vector<int> tree[maxn];
int lev[maxn];
int p[logn][maxn];
Info info[logn][maxn];
void init(int n) {
this->n = n;
for (int i = 0; i < n; i++) {
adj[i].clear();
tree[i].clear();
rem[i] = 0;
}
}
void add(int u, int v, int w) {
adj[u].push_back(make_pair(v, w));
adj[v].push_back(make_pair(u, w));
}
void dfs(int u, int p) {
size[u] = 1;
for (int i = 0; i < (int)adj[u].size(); i++) {
int v = adj[u][i].first;
if (v != p && !rem[v]) {
dfs(v, u);
size[u] += size[v];
}
}
}
int findcentroid(int u) {
dfs(u, -1);
int p = -1, t = size[u];
while (1) {
pair<int, int> best;
for (int i = 0; i < (int)adj[u].size(); i++) {
int v = adj[u][i].first;
if (v != p && !rem[v]) {
best = max(best, make_pair(size[v], v));
}
}
if (best.first + best.first <= t) {
return u;
}
p = u, u = best.second;
}
}
void upd(int u, int dep, int p) {
for (int i = 0; i < (int)adj[u].size(); i++) {
int v = adj[u][i].first;
int w = adj[u][i].second;
if (v != p && !rem[v]) {
info[dep][v] = info[dep][u] + w;
upd(v, dep, u);
}
}
}
int divide(int u, int dep) {
lev[u = findcentroid(u)] = dep;
p[0][u] = u;
info[dep][u] = Info(0, 0, 0);
upd(u, dep, -1);
rem[u] = 1;
for (int i = 0; i < (int)adj[u].size(); i++) {
int v = adj[u][i].first;
if (!rem[v]) {
int w = divide(v, dep + 1);
tree[u].push_back(w);
p[0][w] = u;
}
}
return u;
}
int lca(int u, int v) {
if (lev[u] < lev[v]) swap(u, v);
for (int k = logn - 1; k >= 0; k--) {
if (lev[p[k][u]] >= lev[v]) {
u = p[k][u];
}
}
if (u == v) return u;
for (int k = logn - 1; k >= 0; k--) {
if (p[k][u] != p[k][v]) {
u = p[k][u], v = p[k][v];
}
}
return p[0][u];
}
void build() {
rt = divide(0, 0);
for (int k = 1; k < logn; k++) {
for (int u = 0; u < n; u++) {
p[k][u] = p[k - 1][p[k - 1][u]];
}
}
}
map<int, int> hs;
long long ans;
void add(int u, int ix) {
hs[info[ix][u].y]++;
for (int i = 0; i < (int)tree[u].size(); i++) {
int v = tree[u][i];
add(v, ix);
}
}
void del(int u, int ix) {
hs[info[ix][u].y]--;
for (int i = 0; i < (int)tree[u].size(); i++) {
int v = tree[u][i];
del(v, ix);
}
}
void query(int u, int ix) {
int z = mult(info[ix][u].x, ip10[info[ix][u].d], m);
z = (m - z) % m;
ans += hs[z];
ans += !info[ix][u].x;
ans += !info[ix][u].y;
for (int i = 0; i < (int)tree[u].size(); i++) {
int v = tree[u][i];
query(v, ix);
}
}
void work(int u) {
hs.clear();
int ix = lev[u];
for (int i = 0; i < (int)tree[u].size(); i++) {
int v = tree[u][i];
add(v, ix);
}
for (int i = 0; i < (int)tree[u].size(); i++) {
int v = tree[u][i];
del(v, ix);
query(v, ix);
add(v, ix);
}
for (int i = 0; i < (int)tree[u].size(); i++) {
int v = tree[u][i];
work(v);
}
}
} ct;
void solve() {
cin >> n >> m;
ct.init(n);
for (int i = (0); i < (n - 1); i++) {
int u, v, w;
cin >> u >> v >> w;
w %= m;
ct.add(u, v, w);
}
p10[0] = 1;
for (int i = (1); i < (maxn); i++) p10[i] = mult(p10[i - 1], 10, m);
for (int i = (0); i < (maxn); i++) ip10[i] = inverse(p10[i], m);
ct.build();
ct.work(ct.rt);
cout << ct.ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
const double expp = 1e-10;
int n;
int main() {
int T;
cin >> T;
while (T--) {
long long a, b;
cin >> a >> b;
if (a <= (b - 1) / 2 + 1)
cout << (b - 1) / 2 << endl;
else {
cout << b - a << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
const int oo = 1e9;
int n, m, q;
int l[maxn], r[maxn], dist[maxn], trace[maxn];
int c[maxn][maxn], d[maxn][maxn], f[maxn][maxn];
int getsign(int x) {
if (x >= 0)
return 1;
else
return -1;
}
bool findpath() {
for (int i = 1; i <= m; i++) dist[i] = oo;
dist[1] = 0;
while (1) {
bool stop = true;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= m; j++)
if (f[i][j] < c[i][j] &&
dist[j] > dist[i] + d[i][j] * getsign(f[i][j])) {
dist[j] = dist[i] + d[i][j] * getsign(f[i][j]);
trace[j] = i;
stop = false;
}
if (stop) break;
}
return dist[2] != oo;
}
void incflow() {
int v = 2;
while (v != 1) {
int u = trace[v];
if (d[u][v] != 0) {
if (f[u][v] < 0) {
d[u][v] -= 2;
d[v][u] -= 2;
} else {
d[u][v] += 2;
d[v][u] += 2;
}
}
f[u][v]++;
f[v][u]--;
v = u;
}
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
l[i] = 1;
r[i] = n;
}
for (int i = 1; i <= q; i++) {
int k, x, y, z;
scanf("%d %d %d %d", &k, &x, &y, &z);
for (int j = x; j <= y; j++)
if (k == 1)
l[j] = max(l[j], z);
else
r[j] = min(r[j], z);
}
for (int i = 1; i <= n; i++) {
if (l[i] > r[i]) {
printf("-1");
return 0;
}
c[1][i + 2] = oo;
d[1][i + 2] = 1;
d[i + 2][1] = -1;
for (int j = 1; j <= n; j++)
if (i >= l[j] && i <= r[j]) c[i + 2][j + 2 + n] = 1;
c[i + 2 + n][2] = 1;
}
m = 2 + n + n;
int ans = 0;
while (findpath()) incflow();
for (int i = 1; i <= n; i++) ans += f[1][2 + i] * f[1][2 + i];
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int u[300005][10];
char v[6] = {'R', 'G', 'B'};
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string s;
cin >> s;
int k = 0;
for (int i = 0; i < n - 1; i++) {
if (s[i] == s[i + 1]) {
k++;
if (i == n - 2) {
for (int j = 0; j < 3; j++) {
if (s[i] != v[j]) {
s[i + 1] = v[j];
break;
}
}
continue;
}
for (int j = 0; j < 3; j++) {
if (s[i] != v[j] && s[i + 2] != v[j]) {
s[i + 1] = v[j];
break;
}
}
}
}
cout << k << endl;
cout << s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = (long long int)1e9 + 10;
const long long int INFLL = (long long int)1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-18;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
long long int ax, ay, bx, by, bxa, bya, bxb, byb;
bool check(long long int arx, long long int ary) {
long long int tx = bx - arx;
long long int ty = by - ary;
if (bxa == 0 && bya == 0) return tx == 0 && ty == 0;
long long int dor = bxa * byb - bxb * bya;
assert(dor != 0);
long long int nx = byb * tx - bxb * ty;
long long int ny = -bya * tx + bxa * ty;
return nx % dor == 0 && ny % dor == 0;
}
int main() {
scanf("%lld %lld", &ax, &ay);
scanf("%lld %lld", &bx, &by);
scanf("%lld %lld", &bxa, &bya);
bxb = -bya;
byb = bxa;
if (check(ax, ay) || check(-ax, -ay) || check(ay, -ax) || check(-ay, ax))
puts("YES");
else
puts("NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
void solve() {
long long n, r, avg;
cin >> n >> r >> avg;
vector<pair<long long, long long>> p(n);
long long a, b;
long long s = 0;
for (long long i = 0; i < n; i++) {
cin >> p[i].first >> p[i].second;
s += p[i].first;
}
long long w = (avg * n) - s;
long long ans = 0;
sort(p.begin(), p.end(), cmp);
for (long long i = 0; i < n and w > 0; i++) {
if (p[i].first < r) {
if (w > r - p[i].first) {
ans += (r - p[i].first) * (p[i].second);
w -= r - p[i].first;
} else {
ans += w * p[i].second;
w = 0;
}
}
}
cout << ans << endl;
}
int32_t main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 6600;
int n;
int Pop[NMAX];
vector<int> AdjOf[NMAX];
int C[NMAX];
int Opt[NMAX];
bool Visited[NMAX];
int myBest = 1;
void readInput() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> Pop[i];
};
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
AdjOf[x].push_back(y);
AdjOf[y].push_back(x);
};
};
int LIS2(int len, int from) {
set<int> st;
set<int>::iterator it;
st.clear();
int i;
for (i = 0; i <= len; i++) {
st.insert(C[i]);
it = st.find(C[i]);
it++;
if (it != st.end()) st.erase(it);
}
return st.size();
};
int LIS(int len) {
vector<int> BB;
BB.clear();
int u, v, i;
int best = 1;
BB.push_back(0);
for (i = 1; i <= len; i++) {
if (C[BB.back()] < C[i]) {
BB.push_back(i);
best = max(best, (int)BB.size());
continue;
}
for (u = 0, v = BB.size() - 1; u < v;) {
int c = (u + v) / 2;
if (C[BB[c]] < C[i])
u = c + 1;
else
v = c;
};
if (C[i] < C[BB[u]]) {
BB[u] = i;
}
}
return best;
}
void bestFrom(int u, int len) {
C[len] = Pop[u];
bool leaf = true;
for (int iv = 0; iv < AdjOf[u].size(); iv++) {
int v = AdjOf[u][iv];
if (!Visited[v]) {
leaf = false;
Visited[v] = true;
bestFrom(v, len + 1);
Visited[v] = false;
};
};
if (leaf) {
if (len >= myBest) {
int lis;
lis = LIS(len);
myBest = myBest < lis ? lis : myBest;
};
};
}
void solveIt() {
myBest = 1;
for (int i = 1; i <= n; i++) {
if (AdjOf[i].size() > 1) continue;
for (int j = 0; j <= n; j++) {
C[j] = 0;
Visited[j] = false;
Opt[i] = 1;
};
Visited[i] = true;
bestFrom(i, 0);
}
cout << myBest << endl;
};
int main() {
readInput();
solveIt();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int dp1[N], dpn[N], p[N], v[N];
vector<int> pozitii[N], updates[N];
vector<pair<int, int> > queries[N];
bool ans[N];
int n, m;
int cb(int val, int poz) {
int pas(1 << 17), r(-1);
while (pas) {
if (r + pas < pozitii[val].size() && pozitii[val][r + pas] < poz) r += pas;
pas >>= 1;
}
return r;
}
void precalc() {
for (int i = 1; i <= m; ++i) pozitii[v[i]].push_back(i);
for (int i = 1; i <= m; ++i) {
if (v[i] == 1) {
dp1[i] = i;
continue;
}
if (pozitii[v[i] - 1].size() == 0 || pozitii[v[i] - 1].front() > i) {
dp1[i] = -1;
continue;
}
int p = cb(v[i] - 1, i);
assert(p != -1);
dp1[i] = dp1[pozitii[v[i] - 1][p]];
}
for (int i = m; i >= 1; --i) {
if (v[i] == n) {
dpn[i] = i;
continue;
}
if (pozitii[v[i] + 1].size() == 0 || pozitii[v[i] + 1].back() < i) {
dpn[i] = -1;
continue;
}
int p = cb(v[i] + 1, i);
dpn[i] = dpn[pozitii[v[i] + 1][p + 1]];
}
for (int i = 1; i <= m; ++i) {
int x = dp1[i];
if (dp1[i] == -1) continue;
if (v[i] == n) {
updates[x].push_back(i);
continue;
}
int pas = 1 << 17, r(-1);
while (pas) {
if (r + pas < pozitii[v[i] + 1].size() &&
dpn[pozitii[v[i] + 1][r + pas]] != -1 &&
dpn[pozitii[v[i] + 1][r + pas]] < x)
r += pas;
pas >>= 1;
}
if (r != -1) updates[pozitii[v[i] + 1][r]].push_back(i);
}
}
void solve() {
int cur(1e9);
for (int i = m; i >= 1; --i) {
for (auto j : updates[i]) cur = min(cur, j);
for (auto j : queries[i])
if (cur <= j.first) ans[j.second] = 1;
}
}
int main() {
int q, val;
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) cin >> val, p[val] = i;
for (int i = 1; i <= m; ++i) {
cin >> v[i];
v[i] = p[v[i]];
}
precalc();
int st, dr;
for (int i = 1; i <= q; ++i) {
cin >> st >> dr;
queries[st].push_back({dr, i});
}
solve();
for (int i = 1; i <= q; ++i) cout << ans[i];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x;
}
int A[maxn], B[maxn], N, MOD, fir, d, len;
int ksm(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = (long long)x * x % MOD)
if (y & 1) res = (long long)res * x % MOD;
return res;
}
void Solve(int *P, int Len) {
int kd = P[1] - P[0], cnt = 0;
map<int, bool> vis;
for (int i = 0; i < N; ++i) vis[P[i]] = true;
for (int i = 0; i < N; ++i)
if (!vis.count((P[i] + kd) % MOD)) ++cnt;
d = (long long)kd * ksm(cnt, MOD - 2) % MOD;
fir = -1;
len = (MOD - d) % MOD;
for (int i = 0; i < N; ++i)
if (!vis.count((P[i] + d) % MOD))
if (~fir) {
fir = -1;
break;
} else
fir = P[i];
}
int main() {
MOD = read();
N = read();
for (int i = 0; i < N; ++i) A[i] = read();
if (N == 1 || N == MOD)
printf("%d 1\n", A[0]);
else {
sort(A, A + N);
if (2 * N < MOD)
Solve(A, N);
else {
map<int, bool> vis;
for (int i = 0; i < N; ++i) vis[A[i]] = true;
N = 0;
for (int i = 0; i < MOD; ++i)
if (!vis.count(i)) B[N++] = i;
Solve(B, N);
if (~fir) (fir += (long long)len * N % MOD) %= MOD;
}
if (~fir)
printf("%d %d\n", fir, len);
else
puts("-1");
}
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.