solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e4 + 20;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int a[105];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = 0, sum = 0;
for (int i = 0; i < k; i++) {
sum = 0;
for (int j = i; j < n; j += k) {
if (a[j] == 1) sum++;
}
ans = ans + min(sum, n / k - sum);
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], b[100010], c[100010];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int x;
scanf("%d", &x);
b[j] = 1 + (x >= a[j] ? b[j] : 0);
a[j] = x;
c[i] = max(c[i], b[j]);
}
}
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (c[r] >= r - l + 1) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
const long long int INF = LONG_LONG_MAX;
const long long int adj4[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const long long int adj8[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int powMod(long long int a, long long int b) {
long long int n = 1;
long long int p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= MOD;
}
p *= p;
p %= MOD;
b /= 2;
}
return n;
}
long long int modularInverse(long long int a) { return powMod(a, MOD - 2); }
stringstream sss;
const long long int maxn = 2010;
long long int n, k;
string S[maxn];
long long int lcp[maxn];
vector<long long int> solve(long long int l, long long int r) {
vector<long long int> dp(k + 1, -BIG);
dp[0] = dp[1] = 0;
if (r - l <= 1) {
return dp;
}
long long int mni = l;
for (long long int i = (l); i < (r - 1); ++i) {
if (lcp[i] < lcp[mni]) {
mni = i;
}
}
vector<long long int> lt = solve(l, mni + 1);
vector<long long int> rt = solve(mni + 1, r);
for (long long int i = (0); i < (k + 1); ++i) {
for (long long int j = (0); j < (i + 1); ++j) {
dp[i] = max(dp[i], (lt[j] + rt[i - j] + lcp[mni] * j * (i - j)));
}
}
return dp;
}
void MAIN() {
cin >> n >> k;
for (long long int i = (0); i < (n); ++i) {
cin >> S[i];
}
sort(S, S + n);
for (long long int i = (0); i < (n - 1); ++i) {
long long int j = 0;
long long int len = min(S[i].size(), S[i + 1].size());
while (j < len && S[i][j] == S[i + 1][j]) {
++j;
}
lcp[i] = j;
}
cout << (solve(0, n)[k]) << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
4 4
aaa
abba
abbc
abbd
)";
MAIN();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void fun(int n, int x);
int main() {
int t;
int n, x;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
cin >> x;
fun(n, x);
}
}
void fun(int n, int x) {
int sum = 2, h = 0;
for (int i = 0; i <= n; i++) {
sum = 2;
sum += x * i;
h++;
if (sum >= n) {
cout << h << "\n";
break;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
constexpr int TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T>
T pow(T x, ll n) {
T r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
template <uint MD>
struct ModInt {
uint v;
ModInt() : v(0) {}
ModInt(ll v) : v(normS(v % MD + MD)) {}
uint value() { return v; }
static uint normS(const uint &x) { return (x < MD) ? x : x - MD; };
static ModInt make(const uint &x) {
ModInt m;
m.v = x;
return m;
}
const ModInt operator+(const ModInt &r) const { return make(normS(v + r.v)); }
const ModInt operator-(const ModInt &r) const {
return make(normS(v + normS(MD - r.v)));
}
const ModInt operator*(const ModInt &r) const {
return make((ull)v * r.v % MD);
}
ModInt &operator+=(const ModInt &r) { return *this = *this + r; }
ModInt &operator-=(const ModInt &r) { return *this = *this - r; }
ModInt &operator*=(const ModInt &r) { return *this = *this * r; }
static ModInt inv(const ModInt &x) { return pow(ModInt(x), MD - 2); }
};
const ll MD = 1e9 + 7;
using Mint = ModInt<MD>;
const int MN = 200100;
const int D = 1001001;
int k;
Mint comb[MN];
Mint sm;
Mint kei[D + 1];
int co[D + 1];
void cop(int x) {
sm -= comb[co[x]] * kei[x];
co[x]++;
sm += comb[co[x]] * kei[x];
}
void addn(int x) {
for (int i = 1; i * i <= x; i++) {
if (x % i == 0) {
cop(i);
if (i * i != x) cop(x / i);
}
}
}
Mint fact[MN], ifac[MN];
void init() {
for (int i = 1; i <= D; i++) {
kei[i] = Mint(i) - kei[i];
for (int j = 2 * i; j <= D; j += i) {
kei[j] += kei[i];
}
}
fact[0] = 1;
for (int i = 1; i < MN; i++) {
fact[i] = fact[i - 1] * i;
}
for (int i = 0; i < MN; i++) {
ifac[i] = Mint::inv(fact[i]);
}
for (int i = 0; i < k; i++) {
comb[i] = 0;
}
for (int i = k; i < MN; i++) {
comb[i] = fact[i] * ifac[k] * ifac[i - k];
}
}
int main() {
int n, q;
scanf("%d %d %d", &n, &k, &q);
init();
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
addn(x);
}
for (int i = 0; i < q; i++) {
int x;
scanf("%d", &x);
addn(x);
printf("%d\n", sm.v);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int n;
long long x[100050], y[100050], z[100050], xans, yans, zans;
inline void Init() {
for (int i = 1; i <= n; i++) x[i] = y[i] = z[i] = 0;
xans = yans = zans = 0;
}
inline bool check(long long mid) {
long long r1 = 4e18, r2 = 4e18, r3 = 4e18, r4 = 4e18;
long long l1 = -4e18, l2 = -4e18, l3 = -4e18, l4 = -4e18;
for (int i = 1; i <= n; i++) {
r1 = min(r1, mid + x[i] + y[i] + z[i]);
r2 = min(r2, mid - x[i] + y[i] + z[i]);
r3 = min(r3, mid + x[i] - y[i] + z[i]);
r4 = min(r4, mid + x[i] + y[i] - z[i]);
l1 = max(l1, -mid + x[i] + y[i] + z[i]);
l2 = max(l2, -mid - x[i] + y[i] + z[i]);
l3 = max(l3, -mid + x[i] - y[i] + z[i]);
l4 = max(l4, -mid + x[i] + y[i] - z[i]);
}
for (int i = 0; i <= 1; i++) {
long long l11 = l1 + ((l1 & 1) ^ i);
long long r11 = r1 - ((r1 & 1) ^ i);
long long l21 = l2 + ((l2 & 1) ^ i);
long long r21 = r2 - ((r2 & 1) ^ i);
long long l31 = l3 + ((l3 & 1) ^ i);
long long r31 = r3 - ((r3 & 1) ^ i);
long long l41 = l4 + ((l4 & 1) ^ i);
long long r41 = r4 - ((r4 & 1) ^ i);
if (l11 <= r11 && l21 <= r21 && l31 <= r31 && l41 <= r41) {
long long a = l21;
long long b = l31;
long long c = l41;
if (a + b + c <= r11) {
if (a + b + c < l11) {
if (r21 < l11 - b - c)
a = r21;
else
a = l11 - b - c;
}
if (a + b + c < l11) {
if (r31 < l11 - a - c)
b = r31;
else
b = l11 - a - c;
}
if (a + b + c < l11) {
if (r41 < l11 - a - b)
c = r41;
else
c = l11 - a - b;
}
if (a + b + c >= l11) {
xans = (b + c) >> 1;
yans = (a + c) >> 1;
zans = (a + b) >> 1;
return 1;
}
}
}
}
return 0;
}
int main() {
int T = read();
while (T--) {
n = read();
Init();
for (int i = 1; i <= n; i++) {
x[i] = read();
y[i] = read();
z[i] = read();
}
if (n == 1) {
cout << x[1] << " " << y[1] << " " << z[1] << endl;
continue;
}
long long left = 0, right = 4e18;
while (left <= right) {
long long mid = (left + right) >> 1;
if (check(mid))
right = mid - 1;
else
left = mid + 1;
}
cout << xans << " " << yans << " " << zans << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, MOD = 1e9 + 7, INF = 1e9 + 10, SQ = 550, LOG = 25;
int n, m, x1, x2, d, z, t, y2, a[N], mini, ptr, x, y, k, ptr1, ptr2, ans;
vector<int> v[N << 2];
void upd(int b, int e, int pos) {
if (b > x || e <= x) return;
v[pos].push_back(y);
if (e - b == 1) return;
int mid = e + b >> 1, lch = pos << 1, rch = lch + 1;
upd(b, mid, lch);
upd(mid, e, rch);
}
void getsort(int b, int e, int pos) {
sort(v[pos].begin(), v[pos].end());
if (e - b == 1) return;
int mid = e + b >> 1, lch = pos << 1, rch = lch + 1;
getsort(b, mid, lch);
getsort(mid, e, rch);
}
int getbs(int b, int e, int pos, int l, int r) {
if (b >= r || e <= l) return 0;
if (l <= b && e <= r) {
if (v[pos].empty()) return 0;
int be = -1, en = v[pos].size() - 1, mide;
while (en - be > 1) {
mide = en + be >> 1;
if (v[pos][mide] >= x)
en = mide;
else
be = mide;
}
if (v[pos][en] < x) return 0;
return v[pos].size() - en;
}
int mid = e + b >> 1, lch = pos << 1, rch = lch + 1;
return getbs(b, mid, lch, l, r) + getbs(mid, e, rch, l, r);
}
int main() {
scanf("%d %d", &n, &m);
while (n--) {
scanf("%d %d", &x, &y);
upd(1, N, 1);
}
getsort(1, N, 1);
while (m--) {
scanf("%d", &y);
ptr = 1;
ans = 0;
while (y--) {
scanf("%d", &x);
ans += getbs(1, N, 1, ptr, x + 1);
ptr = x + 1;
}
printf("%d\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int c[100009], s[100009];
map<int, vector<long long> > mapa;
vector<pair<int, vector<long long> > > lista;
int n;
bool cmp(const pair<int, vector<long long> > &A,
const pair<int, vector<long long> > &B) {
return A.second.size() > B.second.size();
}
pair<long long, int> best[100009];
int ret[100009], sz;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", c + i, s + i);
mapa[c[i]].push_back(s[i]);
}
for (typeof mapa.begin() it = mapa.begin(); it != mapa.end(); it++)
lista.push_back(make_pair(it->first, it->second));
sort((lista).begin(), (lista).end(), cmp);
for (int i = 0; i < lista.size(); i++) {
sort((lista[i].second).rbegin(), (lista[i].second).rend());
for (int j = 1; j < lista[i].second.size(); j++)
lista[i].second[j] += lista[i].second[j - 1];
}
long long res = -1;
int a, b;
for (int i = 0; i < 100009; i++) best[i] = make_pair(-1LL, 0);
for (int i = 0; i < lista.size(); i++) {
int t = lista[i].second.size() - 1;
if (best[t].first != -1 && best[t].first + lista[i].second[t] > res)
res = best[t].first + lista[i].second[t], a = best[t].second,
b = lista[i].first;
if (best[t + 1].first != -1 && best[t + 1].first + lista[i].second[t] > res)
res = best[t + 1].first + lista[i].second[t], a = best[t + 1].second,
b = lista[i].first;
for (int j = 0; j < t + 1; j++)
best[j] = max(best[j], make_pair(lista[i].second[j], lista[i].first));
}
vector<pair<int, int> > A, B;
for (int i = 0; i < n; i++)
if (c[i] == a)
A.push_back(make_pair(s[i], i));
else if (c[i] == b)
B.push_back(make_pair(s[i], i));
sort((A).rbegin(), (A).rend());
sort((B).rbegin(), (B).rend());
int bb = B.size(), aa = min(B.size() + 1, A.size());
sz = 0;
for (int i = 0; i < bb; i++) ret[sz++] = A[i].second, ret[sz++] = B[i].second;
if (bb != aa) ret[sz++] = A[bb].second;
cout << res << endl << sz << endl;
for (int i = 0; i < sz; i++) {
if (i) printf(" ");
printf("%d", ret[i] + 1);
}
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INFLL = 2 * (long long)1e18 + 100;
const int INFINT = 2 * (int)1e9 + 100;
const double PI = atan(1) * 4;
const double EPS = 1e-9;
const int SEED = 137;
const int MOD = 1e9 + 7;
const int NMAX = 1e5 + 5;
int n, a[NMAX];
long long dp[NMAX];
struct node {
int val, ind;
} nil;
node seg_tree[4 * NMAX];
void update(int nod, int l, int r, int pos, int val) {
if (l == r) {
seg_tree[nod].val = val;
seg_tree[nod].ind = pos;
return;
}
int m = (l + r) / 2;
if (pos <= m)
update(2 * nod, l, m, pos, val);
else
update(2 * nod + 1, m + 1, r, pos, val);
if (seg_tree[2 * nod].val >= seg_tree[2 * nod + 1].val)
seg_tree[nod] = seg_tree[2 * nod];
else
seg_tree[nod] = seg_tree[2 * nod + 1];
}
node query(int nod, int l, int r, int start, int finish) {
if (l > finish || r < start) return nil;
if (l >= start && r <= finish) return seg_tree[nod];
int m = (l + r) / 2;
node L = query(2 * nod, l, m, start, finish);
node R = query(2 * nod + 1, m + 1, r, start, finish);
if (L.val >= R.val)
return L;
else
return R;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n - 1; i++) cin >> a[i];
update(1, 1, n, n, n);
for (int i = n - 1; i >= 1; i--) {
node temp = query(1, 1, n, i + 1, a[i]);
int mmax = temp.ind;
dp[i] = n - i - a[i] + mmax + dp[mmax];
update(1, 1, n, i, a[i]);
}
long long sol = 0;
for (int i = 1; i <= n; i++) sol += dp[i];
cout << sol;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int MV = 9000000;
int vis[MV];
char str[MV];
int f(int x) {
if (x == 0)
return 1;
else if (x == 1)
return 0;
else if (x == 2 || x == 3 || x == 5 || x == 7) {
vis[x]++;
return 0;
} else if (x == 4) {
vis[3]++;
vis[2] += 2;
return 0;
} else if (x == 6) {
vis[5]++;
vis[3]++;
return 0;
} else if (x == 8) {
vis[7]++;
vis[2] += 3;
return 0;
} else if (x == 9) {
vis[7]++;
vis[2] += 1;
vis[3] += 2;
return 0;
}
}
int main() {
int n;
while (~scanf("%d", &n)) {
scanf("%s", str);
memset(vis, 0, sizeof(vis));
int flag = 0;
int can = 0;
for (int i = 0; i < strlen(str); i++) {
if (flag == 0 && str[i] == '0') {
continue;
} else {
flag = 1;
can += f(str[i] - '0');
}
}
for (int i = 9; i >= 0; i--) {
for (int j = 0; j < vis[i]; j++) {
printf("%d", i);
}
}
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const int MAX = (int)1e5 + 5;
int main(void) {
string s;
cin >> s;
string a = "at", d = "dot";
string ans;
int l = s.length();
bool flag = 0;
for (int i = 0; i < (l); ++i) {
if (i > 0 && i <= l - 4 && s.substr(i, 3) == d) {
ans += ".";
i += 2;
} else if (!flag && i > 0 && i <= l - 3 && s.substr(i, 2) == a) {
ans += "@";
i++;
flag = 1;
} else
ans += s[i];
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 3;
long long n, m, k, ans = 0;
long long p[maxn];
long long f(long long i) { return (p[i] - i + k) / k; }
int main() {
scanf("%lld %lld %lld", &n, &m, &k);
for (long long i = 1; i <= m; i++) scanf("%lld", &p[i]);
long long desp = 0;
for (long long i = 1; i <= m;) {
long long block = f(i);
long long new_desp = 0;
ans++;
for (; i <= m && f(i) == block; i++) {
if (p[i] - desp <= k * block) {
new_desp++;
} else {
desp += new_desp;
new_desp = 1;
ans++;
}
}
desp += new_desp;
}
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[2222];
int main() {
if (0) {
freopen("aaa.inp", "r", stdin);
freopen("aaa.out", "w", stdout);
};
scanf("%d\n", &n);
gets(s);
sort(s, s + n);
sort(s + n, s + n + n);
bool ok = 1;
for (int i = 0; i < (int)n; i++) ok &= s[i] < s[i + n];
if (ok) {
puts("YES\n");
return 0;
}
ok = 1;
for (int i = 0; i < (int)n; i++) ok &= s[i] > s[i + n];
if (ok) {
puts("YES\n");
return 0;
}
puts("NO\n");
return 0;
};
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
for (long long o = 0; o < t; o++) {
long long a, b, c;
cin >> a >> b >> c;
if (b == 1 && c == a) {
cout << -1 << " " << -1 << '\n';
} else if (c <= a) {
cout << -1 << " " << b << '\n';
} else if (b == 1) {
cout << 1 << " " << -1 << '\n';
} else if (a * b <= c) {
cout << 1 << " " << -1 << '\n';
} else {
cout << 1 << " " << b << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int degree[100010], sv[100010];
int main() {
long long int n;
cin >> n;
vector<pair<long long int, long long int> > ans;
queue<long long int> q;
for (long long int i = 0; i < n; i++) {
cin >> degree[i] >> sv[i];
if (degree[i] == 1) q.push(i);
}
while (!q.empty()) {
long long int x = q.front();
q.pop();
if (degree[x] == 0) continue;
degree[x]--;
long long int to = sv[x];
sv[x] = 0;
degree[to]--;
sv[to] ^= x;
ans.push_back(make_pair(to, x));
if (degree[to] == 1) q.push(to);
}
cout << ans.size() << endl;
for (long long int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const double EPS = 1e-8;
const int MOD = 1e9 + 7;
long long qpow(long long x, long long n, long long mod = MOD) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
namespace Solver {
void InitOnce() {}
char s[200005];
char t[200005];
void Read() {
int res = scanf("%s%s", s + 1, t + 1);
if (res == -1) exit(0);
}
stack<pair<int, int> > stk;
void Solve() {
while (!stk.empty()) stk.pop();
int n = strlen(s + 1);
int m = strlen(t + 1);
int i = n, j = m;
while (i >= 1 && j >= 1) {
while (i >= 1 && s[i] != t[j]) --i;
if (i == 0) break;
assert(s[i] == t[j]);
stk.push({i, j});
--i;
--j;
}
int L = 1, R = m;
if (stk.size()) R = stk.top().second - 1;
if (R - L + 1 == 0) {
puts(t + 1);
return;
}
i = 1, j = 1;
while (i <= n && j <= m) {
if (stk.size() && stk.top().first == i) stk.pop();
if (stk.size() && stk.top().second == j) stk.pop();
while (i <= n && s[i] != t[j]) {
++i;
if (stk.size() && stk.top().first == i) stk.pop();
}
if (i > n) break;
assert(s[i] == t[j]);
int nL = j + 1, nR = m;
if (stk.size()) nR = stk.top().second - 1;
if (nR - nL < R - L) {
R = nR;
L = nL;
}
++i;
++j;
}
if (R - L + 1 == m) {
puts("-");
return;
}
for (int i = 1; i < L; ++i) putchar(t[i]);
for (int i = R + 1; i <= m; ++i) putchar(t[i]);
putchar('\n');
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) {
Solver::Read();
Solver::Solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void fastRead(int *a) {
register char c = 0;
while (c < 33) c = getchar();
*a = 0;
while (c > 33) {
*a = *a * 10 + c - '0';
c = getchar();
}
}
inline void fastWrite(long long int a) {
char snum[20];
int i = 0;
do {
snum[i++] = a % 10 + 48;
a = a / 10;
} while (a != 0);
i = i - 1;
while (i >= 0) putchar(snum[i--]);
putchar('\n');
}
int n, block;
int arr[200005];
long long int ans[200005];
int num[1000005];
long long int sum;
bool cmp(pair<pair<int, int>, int> p1, pair<pair<int, int>, int> p2) {
if (p1.first.first / block == p2.first.first / block)
return p1.first.second / block < p2.first.second / block;
return p1.first.first / block < p2.first.first / block;
}
void add(int pos) {
int nn = arr[pos];
sum -= (1LL * num[nn] * num[nn]) * 1LL * nn;
num[arr[pos]]++;
sum += (1LL * num[nn] * num[nn]) * 1LL * nn;
}
void remove(int pos) {
long long int nn = arr[pos];
sum -= (1LL * num[nn] * num[nn]) * 1LL * nn;
num[arr[pos]]--;
sum += (1LL * num[nn] * num[nn]) * 1LL * nn;
}
int main() {
ios_base::sync_with_stdio(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> arr[i];
vector<pair<pair<int, int>, int> > v;
block = sqrt(n);
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
a--, b--;
v.push_back(make_pair(make_pair(a, b), i));
}
sort(v.begin(), v.end(), cmp);
int l = 0, r = -1;
for (int i = 0; i < v.size(); i++) {
int id = v[i].second;
int l1 = v[i].first.first;
int r1 = v[i].first.second;
while (l < l1) {
remove(l);
l++;
}
while (l > l1) {
add(l - 1);
l--;
}
while (r < r1) {
add(r + 1);
r++;
}
while (r > r1) {
remove(r);
r--;
}
ans[id] = sum;
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int freq[N];
int sum[N];
int dp1[N];
int dp2[N];
int solve1(int idx) {
if (freq[idx] <= 1) return idx;
int &ans = dp1[idx];
if (~ans) return ans;
return ans = solve1(idx + 1);
}
int solve2(int idx) {
if (freq[idx] <= 1) return idx;
int &ans = dp2[idx];
if (~ans) return ans;
if (idx == 0)
return ans = 0;
else
return ans = solve2(idx - 1);
}
int getsum(int l, int r) {
int ret = sum[r];
if (l) ret -= sum[l - 1];
return ret;
}
void fill1(vector<int> &ans, int element) {
if (element < 0 || freq[element] == 0) return;
if (freq[element] == 1) {
ans.push_back(element);
return;
}
for (int i = 1; i <= freq[element] - 1; i++) ans.push_back(element);
fill1(ans, element - 1);
ans.push_back(element);
}
void fill2(vector<int> &ans, int element) {
if (element >= N || freq[element] == 0) return;
if (freq[element] == 1) {
ans.push_back(element);
return;
}
for (int i = 1; i <= freq[element] - 1; i++) ans.push_back(element);
fill2(ans, element + 1);
ans.push_back(element);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
freq[val]++;
}
for (int i = 0; i < N; i++) {
sum[i] = freq[i];
if (i) sum[i] += sum[i - 1];
}
int ans = 0, e1, e2, solo = -1;
memset(dp1, -1, sizeof dp1);
memset(dp2, -1, sizeof dp2);
for (int i = 0; i < N - 1; i++) {
int element1 = i, element2 = i + 1;
if (freq[element1] == 0 || freq[element2] == 0) {
if (freq[element1] > ans) {
solo = element1;
ans = freq[element1];
} else if (freq[element2] > ans) {
solo = element2;
ans = freq[element2];
}
continue;
}
int up = solve1(element2);
int down = solve2(element1);
int sol = getsum(element2, up) + getsum(down, element1);
if (sol > ans) {
e1 = element1, e2 = element2, solo = -1, ans = sol;
}
}
cout << ans << '\n';
vector<int> out;
if (solo != -1) {
for (int i = 0; i < freq[solo]; i++) out.push_back(solo);
} else {
fill1(out, e1);
fill2(out, e2);
}
for (auto &x : out) cout << x << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 60;
ll s, x;
bool S[N], X[N];
ll mem[N][2];
ll dp(int i, bool pregnant) {
if (i == N - 1) {
if (pregnant == 0) return 1ll;
return 0ll;
}
if (mem[i][pregnant] != -1) return mem[i][pregnant];
ll ans = 0;
for (int bt1 = 0; bt1 < 2; bt1++) {
for (int bt2 = 0; bt2 < 2; bt2++) {
bool _xor = bt1 ^ bt2;
int sum = bt1 + bt2 + pregnant;
bool pregnant2 = 0;
if (sum >= 2) pregnant2 = 1;
sum = sum & 1;
if (_xor != X[i]) continue;
if (sum != S[i]) continue;
ans += dp(i + 1, pregnant2);
}
}
return mem[i][pregnant] = ans;
}
int main() {
cin >> s >> x;
for (ll i = 0; i < N; i++) {
S[i] = (s & (1ll << i)) == 0 ? 0 : 1;
X[i] = (x & (1ll << i)) == 0 ? 0 : 1;
}
memset(mem, -1, sizeof mem);
cout << dp(0, 0) - (s == x ? 2 : 0) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b, c, d;
cin >> a >> b >> c >> d;
if ((a + b) == (c + d) || (a + c) == (b + d) || (a + d) == (b + c))
cout << "YES";
else if ((a + b + c) == d || (a + b + d) == c || (a + c + d) == b ||
(b + c + d) == a)
cout << "YES";
else
cout << "NO";
}
int main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long cdiv(long long a, long long b) {
return a / b + ((a ^ b) > 0 && a % b);
}
long long fdiv(long long a, long long b) {
return a / b - ((a ^ b) < 0 && a % b);
}
void solve() {
string s;
cin >> s;
long long int n = s.size();
long long int r = ceil(n / 20.0);
long long int c = ceil(n / (r + 0.0));
if (r == 1) {
cout << 1 << " " << n << endl;
cout << s;
return;
}
long long int req = r * c - n;
long long int rre = req / r;
long long int zn = req % r;
long long int k = 0;
long long int row = 0;
cout << r << " " << c << endl;
for (long long int i = 0; i < r; i++) {
row = rre;
while (row--) {
cout << "*";
}
long long int flag = 0;
if (zn > 0) {
flag = 1;
cout << "*";
zn--;
}
long long int yc = c - rre;
if (flag) yc--;
for (long long int j = 0; j < yc; j++) {
if (k < n) cout << s[k];
k++;
}
cout << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long r = 1e9;
struct node {
int a, b, c, d;
};
int n, m;
int t;
int k, l;
double a[1005];
string s;
int main() {
cin >> n;
double minx = 0, maxx = r;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (minx < a[i] / i) minx = a[i] / i;
if (maxx > (a[i] + 1) / i) maxx = (a[i] + 1) / i;
}
minx *= (n + 1);
maxx *= (n + 1);
k = (int)floor(minx);
l = (int)ceil(maxx - 1);
if (k == l)
cout << "unique" << endl << k;
else
cout << "not unique";
}
| 5 |
#include <bits/stdc++.h>
typedef struct person {
int num;
int nexts[2000];
} person;
person perArr[2000];
int dfs(int count, int current) {
int out = 0;
int cur = 0;
int i = 0;
if (perArr[current].num == 0) {
return count;
} else {
for (i = 0; i < perArr[current].num; i++) {
cur = dfs(count + 1, perArr[current].nexts[i]);
if (cur > out) {
out = cur;
}
}
return out;
}
}
int main(int argc, char *argv[]) {
int lines;
scanf("%d", &lines);
int noManager[2000] = {0};
int count = 0;
int i = 0;
int c;
for (i = 0; i < lines; i++) {
scanf("%d", &c);
c = c - 1;
if (c == -2) {
noManager[count] = i;
count++;
} else {
perArr[c].nexts[perArr[c].num] = i;
perArr[c].num++;
}
}
int done = 0;
int out = 1;
int cur = 0;
for (i = 0; i < count; i++) {
cur = dfs(1, noManager[i]);
if (cur > out) {
out = cur;
}
}
printf("%d\n", out);
return EXIT_SUCCESS;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
int n, Edge[N][N], deg[N], tmp[N], cnt, Min = 7;
char s[N];
bool Check() {
for (int i = 1; i <= n; ++i) tmp[i] = deg[i];
sort(tmp + 1, tmp + 1 + n);
int sum = 0;
for (int i = 1; i < n; ++i) {
sum += tmp[i];
if (sum == i * (i - 1) / 2) return false;
}
return true;
}
int rev(int x) {
deg[x] = n - 1 - deg[x];
for (int i = 1; i <= n; ++i) {
if (i == x) continue;
if (Edge[i][x])
deg[i]--;
else
deg[i]++;
Edge[i][x] ^= 1;
Edge[x][i] ^= 1;
}
}
void DFS(int now, int c) {
if (c > Min) return;
if (now == n + 1) {
if (Check()) {
Min = c;
cnt++;
}
return;
}
DFS(now + 1, c);
rev(now);
DFS(now + 1, c + 1);
rev(now);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= n; ++j) Edge[i][j] = s[j] - '0', deg[i] += Edge[i][j];
}
if (Check()) return 0 * puts("0 1");
for (int i = 1; i <= n; ++i) {
rev(i);
cnt += Check();
rev(i);
}
if (cnt) return 0 * printf("1 %d\n", cnt);
DFS(1, 0);
if (!cnt) return 0 * puts("-1");
for (int i = 1; i <= Min; ++i) cnt = (1LL * cnt * i) % 998244353;
printf("%d %d\n", Min, cnt);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chmax(T &x, T &y) {
if (x < y) swap(x, y);
}
template <class T>
inline void chmin(T &x, T &y) {
if (x > y) swap(x, y);
}
const long long INF = 0x3f3f3f3f3f3f;
const long long MOD = 1e9 + 7;
const long double EPS = 10e-10;
void Solution() {
long long n, d;
scanf("%lld %lld", &n, &d);
complex<long long> a = {0, d};
complex<long long> b = {n - d, n};
complex<long long> c = {d, 0};
complex<long long> e = {n, n - d};
long long m;
scanf("%lld", &m);
while (m--) {
long long x, y;
scanf("%lld %lld", &x, &y);
complex<long long> p = {x, y};
long long ans1 = (conj(p - a) * (p - b)).imag();
long long ans2 = (conj(p - c) * (p - e)).imag();
long long ans3 = (conj(p - a) * (p - c)).imag();
long long ans4 = (conj(p - b) * (p - e)).imag();
if (ans1 * ans2 <= 0 and ans3 * ans4 <= 0)
printf("YES\n");
else
printf("NO\n");
}
}
int32_t main() {
long long tc = 1;
for (long long tn = 1; tn < tc + 1; tn += 1) {
Solution();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()) {
v.assign(a, vector<T>(b, t));
}
int main() {
double pi = acos(-1.0);
int m, n;
cin >> n >> m;
vector<complex<double> > v(2 * m);
double r = 1e8 - 3.0;
double t = 2.0 * pi / m;
double d = 1e-6;
for (int i = 0; i < m; ++i) {
v[i] = polar(r, t * i);
v[i + m] = polar(r - 1e6, t * i + d);
}
v.resize(n);
if (m == 3 && n >= 5) {
puts("-1");
} else {
for (int i = 0; i < n; ++i) {
printf("%d %d\n", (int)real(v[i]), (int)imag(v[i]));
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
const long long MOD = 1000000009;
long long n;
cin >> n;
if (n == 2) {
cout << 10 << "\n";
return 0;
}
long long half = 6;
long long s = n / 2 - 2;
long long path = 1, p2 = 2, num = 1;
for (register int i = (1); i < (int)(s + 1); ++i) {
p2 *= 2;
p2 %= MOD;
path += p2;
path %= MOD;
num *= path;
num %= MOD;
half += num * 4;
half %= MOD;
}
long long res = half * half + 1;
res %= MOD;
res *= 2;
res %= MOD;
cout << res << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool compare(pair<int, int> p1, pair<int, int> p2) {
if (p1.first == p2.first) {
if (p1.second < p2.second)
return true;
else
return false;
} else if (p1.first < p2.first)
return false;
else
return true;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
int a[n + 1];
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back({x, i + 1});
a[i + 1] = x;
}
int m;
cin >> m;
sort(v.begin(), v.end(), compare);
while (m--) {
set<int> s;
int k, pos;
cin >> k >> pos;
int i = 0;
while (k--) {
s.insert(v[i].second);
i++;
}
auto it = s.begin();
pos--;
while (pos--) {
it++;
}
cout << a[*it] << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class L>
bool smax(T& x, L y) {
return x < y ? (x = y, 1) : 0;
}
template <class T, class L>
bool smin(T& x, L y) {
return x > y ? (x = y, 1) : 0;
}
const int maxn = 1e5 + 17;
int n, a[maxn], b[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie();
cin >> n;
vector<int> p;
for (int i = 0; i < n; i++) {
cin >> a[i], b[i] = a[i];
}
sort(b, b + n);
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) p.push_back(i);
}
if (p.size() > 2 || p.size() == 1) return cout << "NO\n", 0;
if (p.empty()) return cout << "YES\n", 0;
swap(a[p[0]], a[p[1]]);
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) return cout << "NO\n", 0;
}
cout << "YES\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int n;
scanf("%d", &n);
int prev = -99;
vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a.begin(), a.end());
for (auto i : a) {
if (i - prev == 1) return 2;
prev = i;
}
return 1;
}
int main(int argc, char **argv) {
int q;
scanf("%d", &q);
while (q--) {
printf("%d\n", read());
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int MOD = 1000000007;
const double eps = 1e-7;
void print(int x) {
cout << x << endl;
exit(0);
}
void PRINT(string x) {
cout << x << endl;
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void upd(T &a, T b) {
(a += b) %= MOD;
}
template <class T>
void mul(T &a, T b) {
a = (long long)a * b % MOD;
}
int n, p, k;
struct node {
int a, b, id;
} a[N];
bool cmp(node a, node b) {
if (a.b == b.b) return a.a < b.a;
return a.b > b.b;
}
bool cmp2(node a, node b) {
if (a.a == b.a) return a.b > b.b;
return a.a > b.a;
}
signed main() {
scanf("%d%d%d", &n, &p, &k);
for (int i = (1) - 1; i <= (n)-1; i++) {
scanf("%d%d", &a[i].a, &a[i].b);
a[i].id = i + 1;
}
sort(a, a + n, cmp);
sort(a, a + (n - (p - k)), cmp2);
set<int> ans;
int m = iinf;
for (int i = (1) - 1; i <= (k)-1; i++) {
ans.insert(a[i].id);
m = min(m, a[i].b);
}
sort(a + k, a + n, cmp);
for (int i = k; i < n && ((int)ans.size()) < p; i++)
if (a[i].b < m || i > n - (p - k) - 1) ans.insert(a[i].id);
for (int x : ans) printf("%d ", x);
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string intPart(string s) {
int pos = s.find('.');
return s.substr(0, pos);
}
int main() {
string s;
cin >> s;
int pos = s.find('.');
string inT = intPart(s);
if (s[pos - 1] == '9')
inT = "GOTO Vasilisa.";
else if (s[pos + 1] > '4')
inT[pos - 1] += 1;
cout << inT;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int q;
cin >> q;
while (q--) {
ll h;
int n;
cin >> h >> n;
vector<ll> p(n);
for (int i = 0; i < n; i++) cin >> p[i];
p.push_back(0);
int magic = 0;
for (int i = 1; i < n; i++) {
if (p[i] - p[i + 1] != 1) {
magic++;
} else
i++;
}
cout << magic << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int child[100005][26], cid = 1;
char in[100005];
int cn;
bool win[100005], lose[100005];
void build(int id, int cur) {
if (cur == cn) return;
int &cc = child[id][in[cur] - 'a'];
if (cc == -1) {
cc = cid++;
}
build(cc, cur + 1);
}
void dfs(int x) {
int num = 0;
for (int i = 0; i < 26; i++) {
if (child[x][i] == -1) continue;
num++;
dfs(child[x][i]);
if (!win[child[x][i]]) win[x] = true;
if (!lose[child[x][i]]) lose[x] = true;
}
if (!num) lose[x] = true;
}
int main() {
memset(child, -1, sizeof(child));
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%s", in);
cn = strlen(in);
build(0, 0);
}
dfs(0);
if (lose[0] && win[0]) {
printf("First\n");
} else if (lose[0]) {
printf("Second\n");
} else if (win[0]) {
if (k & 1) {
printf("First\n");
} else
printf("Second\n");
} else {
printf("Second\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
char s[110], t[110];
int n;
bool ok(int l, int r) {
int po = l;
for (int i = 0; i < n && po <= r; i++) {
if (s[i] == t[po]) {
po++;
}
}
return (po == r + 1);
}
void solve() {
scanf("%d", &n);
scanf("%s%s", s, t);
int c1[26], c2[26];
memset(c1, 0, sizeof(c1));
memset(c2, 0, sizeof(c2));
for (int i = 0; i < n; i++) {
c1[s[i] - 'a']++;
c2[t[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (c1[i] != c2[i]) {
printf("-1\n");
return;
}
}
int ans = n;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
if (ok(i, j)) {
ans = min(ans, n - (j - i + 1));
}
}
}
printf("%d\n", ans);
}
int main() {
int tt;
scanf("%d", &tt);
while (tt--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > graph;
vector<int> h, que, d, md;
int n, dist, ans1, ans2, mxh = 0, a, b;
pair<int, int> res;
pair<int, int> ask() {
cout << "? " << que.size() << " ";
for (int i = 0; i < que.size(); ++i) cout << que[i] << " ";
cout << endl;
que.clear();
cin >> a >> b;
return pair<int, int>(a, b);
}
void dfs(int start, int pa) {
md[start] = h[start];
int i, j;
for (i = 0; i < graph[start].size(); ++i) {
j = graph[start][i];
if (j != pa) {
h[j] = h[start] + 1;
mxh = max(mxh, h[j]);
dfs(j, start);
md[start] = max(md[start], md[j]);
}
}
}
void get_node(int start, int pa, int d) {
if (h[start] == d) {
que.push_back(start);
return;
}
for (int i = 0; i < graph[start].size(); ++i)
if (graph[start][i] != pa && md[graph[start][i]] <= n / 2)
get_node(graph[start][i], start, d);
}
void find_second(int start, int pa) {
int i, j;
for (i = 0; i < graph[start].size(); ++i) {
j = graph[start][i];
if (j != pa) {
d[j] = d[start] + 1;
if (d[j] == dist) que.push_back(j);
find_second(j, start);
}
}
}
void solve() {
int i, x, y;
scanf("%d", &n);
graph.assign(n + 1, vector<int>());
for (i = 1; i < n; ++i) {
scanf("%d %d", &x, &y);
graph[x].push_back(y);
graph[y].push_back(x);
}
h.assign(n + 1, 0);
md.assign(n + 1, 0);
for (i = 1; i <= n; ++i) que.push_back(i);
res = ask();
que.clear();
int root = res.first;
dist = res.second;
dfs(root, -1);
int l = 0, r = n / 2, mid;
while (l <= r) {
mid = (l + r) / 2;
get_node(root, -1, mid);
if (que.size() == 0)
r = mid - 1;
else {
res = ask();
if (res.second == dist) {
ans1 = res.first;
l = mid + 1;
} else
r = mid - 1;
}
}
que.clear();
d.assign(n + 1, 0);
find_second(ans1, -1);
res = ask();
ans2 = res.first;
cout << "! " << ans1 << " " << ans2 << endl;
string lmao;
cin >> lmao;
graph.clear();
h.clear();
d.clear();
md.clear();
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mod(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long A[n];
long long mx = 0;
long long mn = 1000000000 + 1;
for (int i = 0; i < n; i++) cin >> A[i];
long long c = 0, p = 0;
for (int i = 0; i < n; i++) {
if (i < n - 1)
if (A[i] != -1 && A[i + 1] != -1) {
p = max(p, mod(A[i], A[i + 1]));
}
if (i < n - 1 && A[i] != -1 && A[i + 1] == -1 ||
i > 0 && A[i - 1] == -1 && A[i] != -1) {
mx = max(mx, A[i]);
mn = min(mn, A[i]);
}
}
long long f;
if ((mx - mn) % 2 == 0)
f = (mx - mn) / 2;
else
f = (mx - mn) / 2 + 1;
if (f <= p)
cout << p << " " << max(mx - p, p) << "\n";
else
cout << f << " " << max(mx - f, f) << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, dx, dy, x, y, a[1000010], b[1000010];
scanf("%d %d %d %d", &n, &m, &dx, &dy);
x = y = 0;
for (int i = 0; i < n; i++) {
x = (x + dx) % n;
y = (y + dy) % n;
a[x] = y;
}
for (int i = 0; i < n; i++) b[i] = 0;
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
b[(y - a[x] + n) % n]++;
}
int rez = -1;
int best = -1;
for (int i = 0; i < n; i++) {
if (b[i] > best) {
best = b[i];
rez = i;
}
}
if (n == 5) {
printf("%d %d\n", (3 * dx) % n, (3 * dy + rez) % n);
} else
printf("0 %d\n", rez);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) {
cout << "YES" << endl;
cout << 1 << " " << 2 << endl;
} else {
if (n % 2 == 0)
cout << "NO" << endl;
else {
vector<int> v(2 * n + 1, 0);
v[1] = 1;
v[n + 1] = 2;
v[2 * n] = 4;
v[n] = 3;
for (int i = 2; i <= (n / 2) + 1; i++) {
if (i % 2) {
v[i] = v[i - 1] + 3;
} else
v[i] = v[i - 1] + 5;
if (i % 2) {
v[i + n] = v[i] + 1;
} else {
v[i + n] = v[i] - 1;
}
}
for (int i = n - 1, count = 1; i >= 0; i--, count++) {
if (v[i] == 0) {
if (count % 2)
v[i] = v[i + 1] + 5;
else
v[i] = v[i + 1] + 3;
} else {
break;
}
}
for (int i = (2 * n) - 1, count = 1; i >= 0; i--, count++) {
if (v[i] == 0) {
if (count % 2)
v[i] = v[i + 1] + 3;
else
v[i] = v[i + 1] + 5;
} else {
break;
}
}
cout << "YES" << endl;
for (int i = 1; i <= 2 * n; i++) cout << v[i] << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int xd[] = {1, 0, -1, 0};
int yd[] = {0, -1, 0, 1};
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)); }
inline bool isEqual(double x, double y) {
const double epsilon = 1e-5;
return abs(x - y) <= epsilon * abs(x);
}
long double triarea(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3) {
return (long double)abs(x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) /
2.0;
}
bool triinside(long x1, long y1, long x2, long y2, long x3, long y3, long x,
long y) {
long area1 = triarea(x1, y1, x2, y2, x3, y3);
long area2 = triarea(x, y, x2, y2, x3, y3);
long area3 = triarea(x1, y1, x, y, x3, y3);
long area4 = triarea(x1, y1, x2, y2, x, y);
if (isEqual(area1, area2 + area3 + area4)) return true;
return false;
}
long long dist(long long x1, long long y1, long long x2, long long y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
const double pi = acos(-1.0);
long double todegree(long double radian) {
if (radian < 0) radian += 2 * pi;
return radian * 180 / pi;
}
long double toradian(long double degree) { return degree * pi / 180.0; }
long long poww(long long a, int b) {
long long ret = 1;
for (int i = 0; i < b; i++) ret *= a;
return ret;
}
long long sumOfNumbers(long long num) {
long long ret = 0;
while (num) {
ret += num % 10;
num /= 10;
}
return ret;
}
unsigned long long fact(unsigned long long n) {
unsigned long long sum = 1;
while (n > 1) {
sum *= n;
n--;
}
return sum;
}
unsigned long long combination(unsigned long long a, unsigned long long b) {
long long ret = 1;
for (int i = 0; i < b; i++) ret = ret * (a - i) / (i + 1);
return ret;
}
int main() {
std::ios_base::sync_with_stdio(0);
long a, b;
cin >> a >> b;
long gc = gcd(a, b);
a /= gc;
b /= gc;
if (abs(a - b) == 1)
cout << "Equal";
else if (b > a)
cout << "Dasha";
else
cout << "Masha";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a, b, c = 0;
scanf("%d%d", &a, &b);
if (b % a != 0)
printf("-1\n");
else {
b /= a;
while (b > 1 && b % 2 == 0) {
b /= 2;
c++;
}
while (b > 1 && b % 3 == 0) {
b /= 3;
c++;
}
if (b != 1)
printf("-1\n");
else
printf("%d\n", c);
}
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const long long mos = 0x7FFFFFFF;
const long long nmos = 0x80000000;
const int inf = 0x3f3f3f3f;
template <typename T>
inline T read(T& x) {
x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x = f ? -x : x;
}
const int maxn = 50;
int a[maxn];
int main() {
int n, k;
string str;
cin >> n >> k >> str;
for (int i = 0; i < n; i++) {
int tmp = str[i] - 'a' + 1;
a[tmp]++;
}
int cnt = 0;
int sum = 0;
for (int i = 1; i <= 26; i++) {
if (a[i] > 0) {
sum += i;
cnt++;
i++;
if (cnt == k) break;
}
}
if (cnt == k) {
printf("%d\n", sum);
} else
puts("-1");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 998244353;
const int N = 3005;
int n, c, a[N];
void UPD(int &x, int y) { (x += y) >= mo ? x -= mo : 233; }
namespace solver1 {
long long f[N][(1 << 12) + 5];
void solve() {
f[0][0] = 1;
int L = (1 << c) - 1;
int S = 0, ST = 0;
for (int i = (int)(1); i <= (int)(n); i++) {
int sta = 1 << (a[i] - 1);
for (int j = (int)(0); j <= (int)(S); j++)
for (int k = (int)(L); k >= (int)(0); k--) f[j][k | sta] += f[j][k];
for (int j = (int)(0); j <= (int)(S); j++)
f[j + 1][0] += f[j][L], f[j][L] = 0;
ST |= sta;
if (ST == L) ST = 0, S++;
if (i % 18 == 0 || i == n)
for (int j = (int)(0); j <= (int)(S); j++)
for (int k = (int)(0); k <= (int)(L); k++) f[j][k] %= mo;
}
for (int i = (int)(0); i <= (int)(n / c); i++) {
int ans = 0;
for (int j = (int)(0); j <= (int)(L); j++) UPD(ans, f[i][j]);
if (i == 0) UPD(ans, mo - 1);
printf("%d ", ans);
}
for (int i = (int)(n / c + 1); i <= (int)(n); i++) printf("%d ", 0);
}
} // namespace solver1
namespace solver2 {
int power(int x, int y) {
int s = 1;
for (; y; y /= 2, x = 1ll * x * x % mo)
if (y & 1) s = 1ll * s * x % mo;
return s;
}
int V[N], IV[N], tr2[N];
int cnt[N], tr1[N][N];
long long f[N][N];
void solve() {
for (int i = (int)(0); i <= (int)(n); i++) {
V[i] = power(2, i) - 1;
IV[i] = power(V[i], mo - 2);
}
for (int i = (int)(1); i <= (int)(n); i++) {
for (int j = (int)(1); j <= (int)(c); j++) cnt[j] = 0;
int GG = c, val = 1;
for (int j = (int)(i); j <= (int)(n); j++) {
if (!cnt[a[j]])
--GG;
else
val = 1ll * val * IV[cnt[a[j]]] % mo;
tr1[i][j] = (GG ? 0 : val);
val = 1ll * val * V[++cnt[a[j]]] % mo;
}
tr2[i] = power(2, n - i + 1);
UPD(tr2[i], mo - (GG ? 0 : val));
}
f[0][0] = tr2[n + 1] = 1;
for (int i = (int)(0); i <= (int)(n / c); i++)
for (int j = (int)(i * c + c); j <= (int)(n); j++) {
unsigned long long tmp = 0;
for (int k = (int)(i * c); k <= (int)(j - c); k++) {
tmp += 1ll * f[i][k] * tr1[k + 1][j];
if ((k & 15) == 15) tmp %= mo;
}
f[i + 1][j] = tmp % mo;
}
for (int i = (int)(0); i <= (int)(n / c); i++) {
int ans = 0;
for (int j = (int)(0); j <= (int)(n); j++)
UPD(ans, 1ll * f[i][j] * tr2[j + 1] % mo);
if (i == 0) UPD(ans, mo - 1);
printf("%d ", ans);
}
for (int i = (int)(n / c + 1); i <= (int)(n); i++) printf("%d ", 0);
}
} // namespace solver2
int main() {
scanf("%d%d", &n, &c);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &a[i]);
if (c <= 11)
solver1::solve();
else
solver2::solve();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int toi[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
long long m;
cin >> s >> m;
int n = s.size();
long long res = 0, tmp = 1;
for (int i = 1; i <= n; i++) {
toi[i] = s[i - 1] - '0';
res = (res * 10 + toi[i]) % m;
tmp = (tmp * 10) % m;
}
long long cur = res;
for (int i = 1; i <= n; i++) {
cur = ((cur * 10 - tmp * toi[i] + toi[i]) % m + m) % m;
if (toi[i + 1]) res = min(res, cur);
}
cout << res << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200000];
int b[1000];
unsigned long long answer = 1;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
if (n > m) {
cout << 0;
return 0;
}
int temp;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 1; j <= i; j++) {
temp = abs(a[i] - a[i - j]) % m;
answer = temp * answer;
answer = answer % m;
}
}
cout << answer % m;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[200200], k, b, c;
vector<int> v;
bool prime[1000100];
void sieve() {
int i;
for (i = 1; i <= 100010; i++) {
prime[i] = 1;
}
prime[1] = 0;
i = 1;
for (i = 1; i <= 1000; i++) {
if (prime[i] == 1) {
v.push_back(i);
for (int j = i * i; j <= 100010; j += i) {
prime[j] = 0;
}
}
}
}
void solve() {
cin >> n;
int i = 0;
int cnt = 0;
for (i; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
bool can = false;
for (int j = 1; j <= 150 and j <= i + 2; j++) {
if (a[i] % j != 0) can = true;
}
if (can) {
cnt++;
}
}
if (cnt == n)
cout << "YES";
else
cout << "NO";
}
int main() {
sieve();
int t;
t = 1;
cin >> t;
while (t--) {
solve();
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t > 0) {
string s = "";
cin >> s;
long long counter = 0, sum = 0;
for (int i = 0; i < s.length(); i++) {
sum += 1;
if (s[i] == '+')
counter += 1;
else
counter -= 1;
if (counter < 0) {
counter = 0;
sum += i + 1;
}
}
cout << sum << "\n";
t -= 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d, s = 0, i;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a >> b >> c >> d;
s = s + (c - a + 1) * (d - b + 1);
}
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool canTell(int way, vector<vector<int>>& mark) {
vector<vector<int>> tmp(5, vector<int>(5, 0));
for (int i = 0; i < 10; i++) {
if (way & (1 << i)) {
if (i < 5) {
for (int j = 0; j < 5; j++) {
tmp[i][j] = i + 1;
}
} else {
for (int j = 0; j < 5; j++) {
tmp[j][i - 5] = tmp[j][i - 5] * 10 + i + 1;
}
}
}
}
for (int i = 0; i < 25; i++) {
if (mark[i / 5][i % 5] == 0) continue;
for (int j = i + 1; j < 25; j++) {
if (mark[j / 5][j % 5] == 0) continue;
if (tmp[i / 5][i % 5] == tmp[j / 5][j % 5]) {
return false;
}
}
}
return true;
}
void solve(int ncase) {
string colors = "RGBYW";
map<char, int> c2i;
for (int i = 0; i < 5; i++) c2i[colors[i]] = i;
int n;
cin >> n;
vector<vector<int>> mark(5, vector<int>(5, 0));
for (int i = 0; i < n; i++) {
string card;
cin >> card;
mark[c2i[card[0]]][card[1] - '1'] = 1;
}
int ans = 10;
for (int k = 0; k < (1 << 10); k++) {
int tmp = __builtin_popcount(k);
if (tmp < ans && canTell(k, mark)) {
ans = min(ans, tmp);
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
int T = 1;
int ncase = 0;
while (T--) {
solve(++ncase);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
signed main() {
cin >> n;
cin >> m;
if (n > 30) {
cout << m << endl;
} else {
long long x = 1;
for (long long i = 0; i < n; i++) x *= 2;
cout << m % x << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m;
cin >> m;
int k;
int discount = 100000;
for (int k = 0; k < m; k++) {
int temp;
cin >> temp;
if (temp < discount) discount = temp;
}
int n;
cin >> n;
int price[100000];
for (int k = 0; k < n; k++) cin >> price[k];
sort(price, price + n);
reverse(price, price + n);
int ans = 0;
int item = 0;
for (int k = 0; k < n; k++) {
ans += price[k];
item++;
if ((item % discount) == 0) {
k += 2;
item = 0;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
map<int, int> mm;
for (int i = 0; i < n; i++) mm[a[i]]++;
vector<int> ans = {a[0]};
for (int i = 0; i < n; i++) {
for (int j = 0; j < 32; j++) {
long long pos1 = a[i] - (1ll << j);
long long pos2 = a[i] + (1ll << j);
vector<int> e = {a[i]};
if (mm.find(pos1) != mm.end()) e.push_back(pos1);
if (mm.find(pos2) != mm.end()) e.push_back(pos2);
if (e.size() > ans.size()) ans = e;
}
}
cout << ans.size() << "\n";
for (auto e : ans) cout << e << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int li, ri, mx, mem;
Node *l;
Node *r;
Node(int from, int to)
: li(from), ri(to), mx(0), mem(0), l(nullptr), r(nullptr) {
if (from < to) {
int mid = (from + to) / 2;
l = new Node(from, mid);
r = new Node(mid + 1, to);
}
}
void push() {
if (mem != 0) {
mx += mem;
l->mem += mem;
r->mem += mem;
mem = 0;
}
}
void update(int from, int to, int val) {
if (from > ri || to < li) {
return;
}
if (from <= li && ri <= to) {
mem += val;
} else {
push();
l->update(from, to, val);
r->update(from, to, val);
mx = max(l->get(li, ri), r->get(li, ri));
}
}
int get(int from, int to) {
if (from > ri || to < li) {
return -10000;
}
if (from <= li && ri <= to) {
return mx + mem;
}
push();
return max(l->get(from, to), r->get(from, to));
}
void print(int lvl = 1) {
for (int i = 0; i < lvl; i++) {
cout << " ";
}
cout << li << " " << ri << " -> " << mem << " " << mx << endl;
if (l) {
l->print(lvl + 1);
r->print(lvl + 1);
}
}
};
int main() {
int n, p, t;
scanf("%d", &n);
vector<int> a(n);
auto root = new Node(0, n - 1);
for (int i = 0; i < n; i++) {
scanf("%d%d", &p, &t);
int v = -1;
if (t == 1) {
scanf("%d", &v);
}
int j = n - p;
a[j] = v;
root->update(j, n - 1, v > 0 ? 1 : -1);
int l = 0, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (root->get(0, mid) > 0) {
r = mid;
} else {
l = mid + 1;
}
}
int ans = -1;
if (r < n) {
ans = a[r];
}
printf("%d\n", ans);
}
}
| 7 |
/*
val = (1 << 1) == 2
val = (1 << 2) == 4
val = (1 << 3) == 8
val = (1 << 4) == 16
------------------------------
------------------------------
val = (1<<n) == 2^n;
*/
#include <bits/stdc++.h>
///#include <ext/pb_ds/assoc_container.hpp>
///#include <ext/pb_ds/tree_policy.hpp>
///using namespace __gnu_pbds;
using namespace std;
#define BsmllH ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define TestCase int tstcase,t; cin>>tstcase; while(tstcase--)
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define sz size
#define br "\n"
#define gap " "
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
#define f0(i,b) for(int i=0;i<(b);i++)
#define f1(i,b) for(int i=1;i<=(b);i++)
#define f2(i,a,b) for(int i=(a);i<=(b);i++)
#define fr(i,b,a) for(int i=(b);i>=(a);i--)
#define maxm 1000000
#define maxn 100
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef pair<ll, int> li;
typedef pair<int, ll> il;
typedef vector<ii> vii;
typedef vector<il> vil;
typedef vector<li> vli;
///typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
vi v;
int fact(int input)
{
if(input==1)
return 1;
else
return input*fact(input-1);
}
int _input(int n)
{
vector < int > vec;
for(int i = 0; i < n; i++)
{
int p;
cin>> p;
vec.pb(p);
}
}
bool parenThesis(string str)
{
stack <char> myStack;
for(int i = 0; str[i]; i++){
if(!myStack.empty() && myStack.top() == '(' && str[i] == ')' )
myStack.pop();
else
myStack.push(str[i]);
}
if(myStack.empty())
return true;
else
return false;
}
void output_vector(vector < int > vec)
{
vector < int > :: iterator it;
for( it = vec.begin(); it != vec.end(); it++)
cout << *it << " ";
cout << '\n';
///for( int i = 0; i < vec.size(); i++)
/// cout << vec[i]<< " ";
/// cout << '\n';
}
int main()
{
BsmllH
///freopen("input.txt", "r", stdin);
///ordered_set os;
TestCase
{
int n;
cin >> n;
int a[n];
f0(i,n) cin >> a[i] ;
bool flag = true;
f0(i,n)
{
int x = sqrt(a[i]);
if(x*x != a[i])
{
flag = false;
break;
}
}
if(flag == false ) cout << "YES" << endl;
else cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double eval(string s) {
int g = 0, t = 0, f = 0, c = 0;
for (unsigned int i = 0; i < s.length(); i++) {
if (s[i] == 'X')
t++;
else if (s[i] == (t & 1 ? 'R' : 'L'))
g++, t++, f = 0;
else
g++, t += 2, c += f, f = !f;
}
if (t & 1) t++, c += f;
if (g * 2 > t) g -= c, t -= c * 2;
return double(g) / t;
}
int main() {
string s, t;
cin >> s;
for (unsigned int i = 0; i < s.length() - 1; i++) {
t += s[i];
if (s[i] != 'X' && s[i] == s[i + 1]) t += 'X';
}
string::iterator a = s.end();
--a;
if (s[s.length() - 1] != (*a))
t += s[s.length() - 1];
else
t += (*a);
double ans;
if (t[0] == t[t.length() - 1] && t[0] != 'X')
ans = max(eval('X' + t), eval(t + 'X'));
else
ans = eval(t);
ans = floor(ans * 1e8) / 1e6;
printf("%.6lf\n", ans);
}
| 10 |
// Jai Shree Ram
#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for(int i=a;i<n;i++)
#define ll long long
#define int long long
#define pb push_back
#define all(v) v.begin(),v.end()
#define endl "\n"
#define x first
#define y second
#define gcd(a,b) __gcd(a,b)
#define mem1(a) memset(a,-1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
#define sz(a) (int)a.size()
#define pii pair<int,int>
#define hell 1000000007
#define elasped_time 1.0 * clock() / CLOCKS_PER_SEC
template<typename T1,typename T2>istream& operator>>(istream& in,pair<T1,T2> &a){in>>a.x>>a.y;return in;}
template<typename T1,typename T2>ostream& operator<<(ostream& out,pair<T1,T2> a){out<<a.x<<" "<<a.y;return out;}
template<typename T,typename T1>T maxs(T &a,T1 b){if(b>a)a=b;return a;}
template<typename T,typename T1>T mins(T &a,T1 b){if(b<a)a=b;return a;}
const int N = 2e5+5;
vector<int>g[N];
map<int,int>mp[N];
map<int,int>cnt;
int a[N];
int pre[N];
void dfs(int u,int v){
mp[u][a[u]]++;
int found=-1;
for(auto i:g[u]){
if(i!=v){
dfs(i,u);
if(mp[i][a[u]]>0){
if(found!=-1){
cout<<0<<endl;exit(0);
}
found=i;
}
if(sz(mp[u])<sz(mp[i]))swap(mp[u],mp[i]);
for(auto j:mp[i]){
mp[u][j.x]+=j.y;
}
}
}
if(cnt[a[u]]>1){
if(mp[u][a[u]]==cnt[a[u]]){
pre[1]++,pre[found]--;
}
else if(mp[u][a[u]]==1){
pre[u]++;
}
else{
pre[1]++;
}
}
}
int ans=0;
void dfs2(int u,int v,int sum=0){
sum+=pre[u];
ans+=(sum==0);
for(auto i:g[u]){
if(i!=v)dfs2(i,u,sum);
}
}
int solve(){
int n;cin>>n;
rep(i,1,n+1){
cin>>a[i];cnt[a[i]]++;
}
rep(i,0,n-1){
int a,b;cin>>a>>b;
g[a].pb(b);
g[b].pb(a);
}
dfs(1,1);
dfs2(1,1,0);
cout<<ans<<endl;
return 0;
}
signed main(){
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#ifdef SIEVE
sieve();
#endif
#ifdef NCR
init();
#endif
int t=1;//cin>>t;
while(t--){
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
void chmin(T1 &a, T2 b) {
if (b < a) a = b;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
vector<long long> divisors(long long n) {
vector<long long> ds;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ds.push_back(i);
if (n / i != i) ds.push_back(n / i);
}
}
sort(ds.begin(), ds.end());
return ds;
}
int main() {
int n;
long long K;
cin >> n >> K;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
if (K == 1) {
cout << 1 << endl;
cout << min_element(a.begin(), a.end()) - a.begin() + 1 << endl;
return 0;
}
vector<int> small(1e6 + 10), large(1e6 + 10);
vector<long long> ds = divisors(K);
int m = ds.size();
for (int i = 0; i < m; i++) {
if (ds[i] <= K / ds[i]) {
small[ds[i]] = i;
} else {
large[K / ds[i]] = i;
}
}
static pair<pair<int, long long>, pair<int, int> > dp[1010][7000];
fill_n(*dp, 1010 * 7000,
make_pair(pair<int, long long>(1e8, 1e17), pair<int, int>(-1, -1)));
dp[0][0] = make_pair(pair<int, long long>(0, 0), pair<int, int>(-1, -1));
for (int i = 0; i < n; i++) {
long long A = gcd(a[i], K);
for (int j = 0; j < m; j++)
if (dp[i][j].first.first < n) {
long long g = A * gcd(ds[j], K / A);
int nj = g <= K / g ? small[g] : large[K / g];
chmin(dp[i + 1][j], dp[i][j]);
chmin(dp[i + 1][nj],
make_pair(pair<int, long long>(dp[i][j].first.first + 1,
dp[i][j].first.second + a[i]),
pair<int, int>(i, j)));
}
}
if (dp[n][m - 1].second.first == -1) {
cout << -1 << endl;
return 0;
}
vector<int> ans;
pair<int, int> p = dp[n][m - 1].second;
while (p.first != -1) {
ans.push_back(p.first);
p = dp[p.first][p.second].second;
}
cout << ans.size() << endl;
for (int x : ans) cout << x + 1 << " ";
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2010;
const int Q = 1e9 + 7;
int l[10], r[10];
int main() {
srand(time(NULL));
int i, j, t, mask, n;
long double p0, p, ans = 0.;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d%d", &l[i], &r[i]);
for (i = 1; i <= 10000; i++) {
p0 = 0.;
for (mask = 1; mask < (1 << n); mask++) {
int c = 0;
for (t = 0; t < n; t++) {
if ((mask >> t) & 1) c++;
}
long double px = 1.;
if (c >= 2) {
for (t = 0; t < n; t++) {
if ((mask >> t) & 1) {
if (l[t] <= i && i <= r[t])
px *= (1 / (long double)(r[t] + 1 - l[t]));
else {
px = 0;
}
} else {
if (l[t] <= i - 1)
px *= ((min(i - 1, r[t]) + 1 - l[t]) /
(long double)(r[t] + 1 - l[t]));
else {
px = 0;
}
}
}
} else
px = 0.;
p0 += px;
for (j = 0; j < n; j++) {
if ((mask >> j) & 1) continue;
p = 1.;
for (t = 0; t < n; t++) {
if (t == j) {
if (i + 1 <= r[j])
p *= ((r[j] + 1 - max(l[j], i + 1)) /
(long double)(r[j] + 1 - l[j]));
else {
p = 0;
}
} else {
if ((mask >> t) & 1) {
if (l[t] <= i && i <= r[t])
p *= (1 / (long double)(r[t] + 1 - l[t]));
else {
p = 0;
}
} else {
if (l[t] <= i - 1)
p *= ((min(i - 1, r[t]) + 1 - l[t]) /
(long double)(r[t] + 1 - l[t]));
else {
p = 0;
}
}
}
}
p0 += p;
}
}
ans += p0 * i;
}
printf("%.15f", (double)ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000005], d, b[2000005], ans;
bool vis[1000005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
while (T--) {
cin >> n >> d, ans = 0;
for (int i = 0; i < n; ++i) cin >> a[i], vis[i] = 0;
for (int i = 0; i < n; ++i)
if (!vis[i]) {
int p = (i + d) % n, cnt = 0, ok = a[i], cur = 0, num = 0;
b[cnt++] = a[i], vis[i] = 1;
while (p != i) {
b[cnt++] = a[p], vis[p] = 1;
if (!a[p]) ok = 0;
p = (p + d) % n;
}
if (ok) {
puts("-1");
goto out;
}
for (int j = cnt; j < (cnt << 1); ++j) b[j] = b[j - cnt];
for (int j = 0; j < (cnt << 1); ++j) {
if (!b[j])
cur = 0;
else
++cur;
num = max(num, cur);
}
ans = max(ans, num);
}
printf("%d\n", ans);
out:;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int MOD = 1000000007;
inline void Add(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<string> a(n + 1);
a[0] = string(m + 1, '#');
for (int i = 1; i <= n; ++i) {
static char s[3010];
s[0] = '#';
scanf("%s", s + 1);
a[i] = s;
}
vector<vector<int>> dp_a(n + 1, vector<int>(m + 1)),
dp_b(n + 1, vector<int>(m + 1));
auto Ok = [&](int i, int j) { return a[i][j] != '#'; };
dp_a[1][2] = 1;
dp_b[2][1] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (!Ok(i, j)) continue;
if (i > 1 || j >= 2) {
if (Ok(i - 1, j)) Add(dp_a[i][j], dp_a[i - 1][j]);
if (Ok(i, j - 1)) Add(dp_a[i][j], dp_a[i][j - 1]);
}
if (j > 1 || i >= 2) {
if (Ok(i - 1, j)) Add(dp_b[i][j], dp_b[i - 1][j]);
if (Ok(i, j - 1)) Add(dp_b[i][j], dp_b[i][j - 1]);
}
}
}
int ans = 1ll * dp_a[n - 1][m] * dp_b[n][m - 1] % MOD;
Add(ans, (-1ll * dp_a[n][m - 1] * dp_b[n - 1][m] % MOD + MOD) % MOD);
printf("%d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[305], b[305], c[305];
int main() {
int n;
pair<long long, long long> p[2];
long long r[2];
for (int i = 0; i < 2; i++) scanf("%lld%lld", &p[i].first, &p[i].second);
scanf("%d", &n);
int ans = 0;
for (int i = 0; i < n; i++) {
scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
for (int j = 0; j < 2; j++)
r[j] = a[i] * p[j].first + b[i] * p[j].second + c[i];
if ((r[0] < 0 and r[1] > 0) or (r[1] < 0 and r[0] > 0)) ans++;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
namespace {
const int N = 500;
const int M = (N - 1) * N + 1;
int n, mod;
void add(int &x, int a) {
x += a;
if (x >= mod) {
x -= mod;
}
}
int fact[N], dp[M], sum[M + 1];
} // namespace
int main() {
scanf("%d%d", &n, &mod);
fact[n - 1] = 1;
for (int i = n - 1; i > 0; -- i) {
fact[i - 1] = fact[i] * (i + 1LL) % mod;
}
int offset = (n - 1) * n / 2;
dp[offset] = sum[offset] = 1 % mod;
sum[offset + 1] = 0;
int result = 0;
int m = 0;
for (int k = 0; k < n; ++k) {
int result_k = 0;
for (int d = 1; d <= k; ++d) {
if (d < m) {
add(result_k,
(k - d + 1LL) *
(sum[offset - m] + mod - sum[offset + std::min(-d, m + 1)]) %
mod);
}
}
add(result, 1LL * fact[k] * result_k % mod);
// x
for (int s = -(m + k); s <= (m + k); ++s) {
// s <= t <= s + k
const int min = std::max(s, -m);
const int max = std::min(s + k, m);
if (min <= max) {
dp[offset + s] = sum[offset + min];
add(dp[offset + s], mod - sum[offset + max + 1]);
}
}
m += k;
sum[offset + m + 1] = 0;
for (int s = m; s >= -m; --s) {
sum[offset + s] = dp[offset + s];
add(sum[offset + s], sum[offset + s + 1]);
}
// y
for (int s = -m; s <= m; ++s) {
// s - k <= t <= s
const int min = std::max(s - k, -m);
const int max = std::min(s, m);
if (min <= max) {
dp[offset + s] = sum[offset + min];
add(dp[offset + s], mod - sum[offset + max + 1]);
}
}
sum[offset + m + 1] = 0;
for (int s = m; s >= -m; --s) {
sum[offset + s] = dp[offset + s];
add(sum[offset + s], sum[offset + s + 1]);
}
}
printf("%d\n", result);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename M>
class Enumeration {
private:
static vector<M> fact, finv, invs;
public:
static void init(int n) {
n = min<decltype(M::mod)>(n, M::mod - 1);
int m = fact.size();
if (n < m) return;
fact.resize(n + 1, 1);
finv.resize(n + 1, 1);
invs.resize(n + 1, 1);
if (m == 0) m = 1;
for (int i = m; i <= n; i++) fact[i] = fact[i - 1] * M(i);
finv[n] = M(1) / fact[n];
for (int i = n; i >= m; i--) finv[i - 1] = finv[i] * M(i);
for (int i = m; i <= n; i++) invs[i] = finv[i] * fact[i - 1];
}
static M Fact(int n) {
init(n);
return fact[n];
}
static M Finv(int n) {
init(n);
return finv[n];
}
static M Invs(int n) {
init(n);
return invs[n];
}
static M C(int n, int k) {
if (n < k || k < 0) return M(0);
init(n);
return fact[n] * finv[n - k] * finv[k];
}
static M P(int n, int k) {
if (n < k || k < 0) return M(0);
init(n);
return fact[n] * finv[n - k];
}
static M H(int n, int k) {
if (n < 0 || k < 0) return M(0);
if (!n && !k) return M(1);
init(n + k - 1);
return C(n + k - 1, k);
}
static M B(int n, int k) {
if (n == 0) return M(1);
k = min(k, n);
init(k);
vector<M> dp(k + 1);
dp[0] = M(1);
for (int i = 1; i <= k; i++)
dp[i] = dp[i - 1] + ((i & 1) ? -finv[i] : finv[i]);
M res(0);
for (int i = 1; i <= k; i++) res += M(i).pow(n) * finv[i] * dp[k - i];
return res;
}
static M LagrangePolynomial(vector<M>& y, M t) {
int n = y.size() - 1;
if (t.v <= n) return y[t.v];
init(n + 1);
vector<M> dp(n + 1, 1), pd(n + 1, 1);
for (int i = 0; i < n; i++) dp[i + 1] = dp[i] * (t - M(i));
for (int i = n; i > 0; i--) pd[i - 1] = pd[i] * (t - M(i));
M res(0);
for (int i = 0; i <= n; i++) {
M tmp = y[i] * dp[i] * pd[i] * finv[i] * finv[n - i];
if ((n - i) & 1)
res -= tmp;
else
res += tmp;
}
return res;
}
};
template <typename M>
vector<M> Enumeration<M>::fact = vector<M>();
template <typename M>
vector<M> Enumeration<M>::finv = vector<M>();
template <typename M>
vector<M> Enumeration<M>::invs = vector<M>();
template <typename M>
M bell(int n, int k) {
if (n == 0) return M(1);
using E = Enumeration<M>;
k = min(k, n);
E::init(k);
vector<M> dp(k + 1);
dp[0] = M(1);
for (int i = 1; i <= k; i++)
dp[i] = dp[i - 1] + ((i & 1) ? -E::Finv(i) : E::Finv(i));
M res(0);
for (int i = 1; i <= k; i++) res += M(i).pow(n) * E::Finv(i) * dp[k - i];
return res;
}
template <typename T, T MOD = 1000000007>
struct Mint {
static constexpr T mod = MOD;
T v;
Mint() : v(0) {}
Mint(signed v) : v(v) {}
Mint(long long t) {
v = t % MOD;
if (v < 0) v += MOD;
}
Mint pow(long long k) {
Mint res(1), tmp(v);
while (k) {
if (k & 1) res *= tmp;
tmp *= tmp;
k >>= 1;
}
return res;
}
static Mint add_identity() { return Mint(0); }
static Mint mul_identity() { return Mint(1); }
Mint inv() { return pow(MOD - 2); }
Mint& operator+=(Mint a) {
v += a.v;
if (v >= MOD) v -= MOD;
return *this;
}
Mint& operator-=(Mint a) {
v += MOD - a.v;
if (v >= MOD) v -= MOD;
return *this;
}
Mint& operator*=(Mint a) {
v = 1LL * v * a.v % MOD;
return *this;
}
Mint& operator/=(Mint a) { return (*this) *= a.inv(); }
Mint operator+(Mint a) const { return Mint(v) += a; }
Mint operator-(Mint a) const { return Mint(v) -= a; }
Mint operator*(Mint a) const { return Mint(v) *= a; }
Mint operator/(Mint a) const { return Mint(v) /= a; }
Mint operator-() const { return v ? Mint(MOD - v) : Mint(v); }
bool operator==(const Mint a) const { return v == a.v; }
bool operator!=(const Mint a) const { return v != a.v; }
bool operator<(const Mint a) const { return v < a.v; }
static Mint comb(long long n, int k) {
Mint num(1), dom(1);
for (int i = 0; i < k; i++) {
num *= Mint(n - i);
dom *= Mint(i + 1);
}
return num / dom;
}
};
template <typename T, T MOD>
constexpr T Mint<T, MOD>::mod;
template <typename T, T MOD>
ostream& operator<<(ostream& os, Mint<T, MOD> m) {
os << m.v;
return os;
}
signed CFR315_B() {
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin >> n;
using M = Mint<int>;
using E = Enumeration<M>;
E::init(n + 1);
M res;
for (int i = 0; i < n; i++) res += E::C(n, i) * bell<M>(i, i);
cout << res.v << endl;
return 0;
}
signed main() {
CFR315_B();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
int f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
int n, a[5050], b[5050];
namespace MaxFlow {
int m, n, s, t, u, v, ca, co, mm, mf, dist[13232], inq[13232], prevv[13232],
preve[13232];
struct edge {
int to, ca, cost, rev;
};
vector<edge> G[13232];
void add_edge(int u, int v, int ca, int co) {
G[u].push_back((edge){v, ca, co, (int)G[v].size()});
G[v].push_back((edge){u, 0, -co, (int)G[u].size() - 1});
}
void run() {
while (1) {
deque<int> que;
memset(dist, 0x3f3f3f3f, sizeof(dist));
memset(inq, 0, sizeof(inq));
dist[s] = 0;
que.push_back(s);
inq[s] = 1;
while (!que.empty()) {
int cur = que.front();
que.pop_front();
inq[cur] = 0;
for (int i = 0; i < G[cur].size(); i++) {
edge cw = G[cur][i];
if (cw.ca <= 0) continue;
if (dist[cw.to] > cw.cost + dist[cur]) {
dist[cw.to] = cw.cost + dist[cur];
prevv[cw.to] = cur;
preve[cw.to] = i;
if (!inq[cw.to]) {
if (que.empty() || dist[cw.to] > dist[que.front()]) {
que.push_back(cw.to);
} else {
que.push_front(cw.to);
}
if (que.size() > 2 && dist[que.front()] > dist[que.back()]) {
int cc = que.front(), dd = que.back();
que.pop_front();
que.pop_back();
que.push_front(dd);
que.push_back(cc);
}
inq[cw.to] = 1;
}
}
}
}
if (dist[t] == 0x3f3f3f3f) break;
int md = 0x3f3f3f3f, di = 0;
for (int p = t; p != s; p = prevv[p]) {
md = min(md, G[prevv[p]][preve[p]].ca);
di += G[prevv[p]][preve[p]].cost;
}
mm += di * md;
mf += md;
for (int p = t; p != s; p = prevv[p]) {
G[prevv[p]][preve[p]].ca -= md;
G[G[prevv[p]][preve[p]].to][G[prevv[p]][preve[p]].rev].ca += md;
}
}
}
void clear() {
mm = mf = 0;
for (int i = 0; i < 13232; i++) G[i].clear();
}
int id(int layer, int x) {
if (layer == 1) return x;
return (layer - 1) * 2 * n - n + x;
}
bool ok(int T) {
clear();
s = 13230;
t = 13231;
n = ::n;
for (int i = 0; i < n; i++) {
add_edge(s, id(1, i), 1, 0);
}
vector<pair<long long, long long> > V2, V3;
for (int i = 0; i < 2 * n; i++) {
V2.push_back(make_pair(b[i], i));
V3.push_back(make_pair(1ll * a[i] * T + b[i], i));
}
sort(V2.begin(), V2.end());
sort(V3.begin(), V3.end());
for (int i = 1; i < n * 2; i++) {
add_edge(id(2, V2[i].second), id(2, V2[i - 1].second), 30000, 0);
add_edge(id(3, V3[i].second), id(3, V3[i - 1].second), 30000, 0);
}
for (int i = 0; i < n; i++) {
int cp = lower_bound(V2.begin(), V2.end(), make_pair(b[i] + 1ll, -1ll)) -
V2.begin() - 1;
cp = V2[cp].second;
add_edge(id(1, i), id(2, cp), 1, 1);
cp = lower_bound(V3.begin(), V3.end(),
make_pair(1ll * a[i] * T + b[i] + 1, -1ll)) -
V3.begin() - 1;
cp = V3[cp].second;
add_edge(id(1, i), id(3, cp), 1, 1);
}
for (int i = 0; i < 2 * n; i++) {
int cp = lower_bound(V3.begin(), V3.end(),
make_pair(1ll * a[i] * T + b[i] + 1, -1ll)) -
V3.begin() - 1;
cp = V3[cp].second;
add_edge(id(2, i), id(3, cp), 30000, 1);
}
for (int i = 0; i < n; i++) {
add_edge(id(2, n + i), id(4, i), 1, 0);
add_edge(id(3, n + i), id(4, i), 1, 0);
add_edge(id(4, i), t, 1, 0);
}
run();
return mf == n;
}
} // namespace MaxFlow
namespace MaxFlowez {
int cnt[5050] = {0};
bool ok(int T) {
memset(cnt, 0, sizeof(cnt));
vector<pair<long long, long long> > V, V2;
for (int i = 0; i < 2 * n; i++) {
V.push_back(make_pair(1ll * a[i] * T + b[i], i));
V2.push_back(make_pair(b[i], 1ll * a[i] * T + b[i]));
}
sort(V.begin(), V.end());
sort(V2.begin(), V2.end());
for (int i = 1; i < n * 2; i++) {
V2[i].second = max(V2[i].second, V2[i - 1].second);
}
for (int i = 0; i < n; i++) {
long long cmx =
V2[lower_bound(V2.begin(), V2.end(), make_pair(b[i] + 1ll, -1ll)) -
V2.begin() - 1]
.second;
int cp = lower_bound(V.begin(), V.end(), make_pair(cmx + 1ll, -1ll)) -
V.begin() - 1;
cnt[cp] += 1;
}
for (int i = n * 2 - 1; i >= 0; i--) {
if (V[i].second >= n) {
cnt[i] -= 1;
if (cnt[i] < 0) return 0;
}
if (i) cnt[i - 1] += cnt[i];
}
return 1;
}
} // namespace MaxFlowez
int main() {
read(n);
for (int i = 0; i < n * 2; i++) {
read(a[i]);
read(b[i]);
}
int l = -1, r = 1e9 + 7;
while (l + 1 != r) {
int mid = (l + r) / 2;
if (MaxFlowez::ok(mid)) {
r = mid;
} else {
l = mid;
}
}
if (r == 1e9 + 7) {
cout << "-1" << endl;
return 0;
}
MaxFlow::ok(r);
cout << r << ' ' << MaxFlow::mm << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long double INF = 1e9;
vector<tuple<int, int, int> > v;
map<pair<long long, tuple<int, int, int> >, long double> mp;
vector<int> e[31][4];
long double pb[] = {1.0 / 6, 1.0 / 6, 1.0 / 3, 1.0 / 3};
int get_pos(vector<tuple<int, int, int> > v, tuple<int, int, int> p) {
return int(lower_bound(v.begin(), v.end(), p) - v.begin());
}
tuple<int, int, int> good_tp(int a, int b, int c) {
if (a > c) swap(a, c);
return tuple<int, int, int>(a, b, c);
}
long long to_num(int a[]) {
int b[8];
for (int i = 0; i < 8; i++) b[i] = a[i];
sort(b, b + 8);
long long r = 0;
for (int i = 0; i < 8; i++) {
r *= 22;
r += b[i];
}
return r;
}
long double ask(pair<long long, tuple<int, int, int> > x) {
if (mp.find(x) != mp.end())
return mp[x];
else {
long long p = x.first;
int a = get<0>(x.second);
int b = get<1>(x.second);
int c = get<2>(x.second);
int id = get_pos(v, x.second);
int A = a, B = b, C = c;
if (A && B && C) A = B = C = 0;
int num[8];
for (int i = 7; i >= 0; i--) num[i] = p % 22, p /= 22;
long double unchanged = pb[0];
bool OK = false;
long double sum = 1;
for (int i = 1; i <= 3; i++) {
bool flag = false;
long double mn = INF;
for (int j = 0; j < 8; j++) {
int t = num[j];
for (int x : e[t][i]) {
flag = true;
OK = true;
num[j] = x;
if (A != a) num[0] = id;
long long next_num = to_num(num);
if (A != a) num[0] = 0;
tuple<int, int, int> next_tp;
if (!A) {
next_tp = good_tp(i, B, C);
mn = min(mn, ask(pair<long long, tuple<int, int, int> >(next_num,
next_tp)));
}
if (!B) {
next_tp = good_tp(A, i, C);
mn = min(mn, ask(pair<long long, tuple<int, int, int> >(next_num,
next_tp)));
}
if (!C) {
next_tp = good_tp(A, B, i);
mn = min(mn, ask(pair<long long, tuple<int, int, int> >(next_num,
next_tp)));
}
num[j] = t;
}
}
if (!flag)
unchanged += pb[i];
else {
sum += pb[i] * mn;
}
}
if (!OK)
return mp[x] = 0;
else {
return mp[x] = sum / (1 - unchanged);
puts("oao");
}
}
}
int char_to_int(char c) {
if (c == 'R')
return 1;
else if (c == 'G')
return 2;
else
return 3;
}
int main() {
for (int i = 0; i <= 3; i++) {
v.emplace_back(0, 0, i);
if (i) e[i][i].push_back(0);
}
int m = 4;
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++)
for (int k = i; k <= 3; k++) {
v.emplace_back(i, j, k);
e[m][j].push_back(0);
e[m][i].push_back(k);
if (i != k) e[m][k].push_back(i);
m++;
}
int n;
scanf("%d", &n);
string second;
int num[8] = {};
for (int ni = 0; ni < n - 1; ni++) {
cin >> second;
int a = char_to_int(second[0]);
int b = char_to_int(second[1]);
int c = char_to_int(second[2]);
tuple<int, int, int> t = good_tp(a, b, c);
num[ni] = get_pos(v, t);
}
cin >> second;
int a = char_to_int(second[0]);
int b = char_to_int(second[1]);
int c = char_to_int(second[2]);
tuple<int, int, int> next_tp = good_tp(a, b, c);
printf("%.9f\n", (double)ask(pair<long long, tuple<int, int, int> >(
to_num(num), next_tp)));
}
| 8 |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
size_t t;
std::cin >> t;
while (t-- > 0) {
size_t n, a, b, c, d;
std::cin >> n >> a >> b >> c >> d;
size_t min = n * (a - b);
size_t max = n * (a + b);
if (max - min + 2 * d >= std::max(c + d, max) - std::min(c - d, min)) {
std::cout << "Yes\n";
} else {
std::cout << "No\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
mt19937_64 rng(
chrono::high_resolution_clock::now().time_since_epoch().count());
int n;
cin >> n;
vector<array<int, 3>> v(n);
for (auto &[x, y, z] : v) cin >> x >> y >> z;
map<array<ll, 2>, array<ll, 2>> mp;
for (int mask = 0; mask < powl(3, n / 2); ++mask) {
array<ll, 3> cur = {0, 0, 0};
int rem = mask;
for (int digit = 0; digit < n / 2; ++digit) {
cur[0] += v[digit][0];
cur[1] += v[digit][1];
cur[2] += v[digit][2];
if (rem % 3 == 0) {
cur[2] -= v[digit][2];
} else if (rem % 3 == 1) {
cur[1] -= v[digit][1];
} else {
cur[0] -= v[digit][0];
}
rem /= 3;
}
ll x = cur[0] - cur[1];
ll y = cur[1] - cur[2];
if (mp.find({x, y}) != mp.end())
mp[{x, y}] = max(mp[{x, y}], {cur[0], mask});
else
mp[{x, y}] = {cur[0], mask};
}
ll ans = -1e15;
int ch = -1, ch2 = -1;
for (int mask = 0; mask < powl(3, n - n / 2); ++mask) {
array<ll, 3> cur{};
int rem = mask;
for (int digit = 0; digit < n - n / 2; ++digit) {
cur[0] += v[n / 2 + digit][0];
cur[1] += v[n / 2 + digit][1];
cur[2] += v[n / 2 + digit][2];
if (rem % 3 == 0)
cur[2] -= v[n / 2 + digit][2];
else if (rem % 3 == 1)
cur[1] -= v[n / 2 + digit][1];
else
cur[0] -= v[n / 2 + digit][0];
rem /= 3;
}
ll x = cur[1] - cur[0];
ll y = cur[2] - cur[1];
if (mp.find({x, y}) == mp.end()) continue;
if (ans < cur[0] + mp[{x, y}][0]) {
ans = cur[0] + mp[{x, y}][0];
ch = mask;
ch2 = mp[{x, y}][1];
}
}
if (ch == -1)
cout << "Impossible\n";
else {
int cur = ch2;
for (int i = 0; i < n / 2; ++i) {
if (cur % 3 == 0)
cout << "LM\n";
else if (cur % 3 == 1)
cout << "LW\n";
else
cout << "WM\n";
cur /= 3;
}
cur = ch;
for (int i = 0; i < n - n / 2; ++i) {
if (cur % 3 == 0)
cout << "LM\n";
else if (cur % 3 == 1)
cout << "LW\n";
else
cout << "WM\n";
cur /= 3;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int n, m;
int ans[N];
int last[N];
vector<int> G[N];
vector<int> in[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
int color;
scanf("%d", &color);
in[color].push_back(i);
if (color > n) {
puts("-1");
exit(0);
}
}
vector<int> result;
for (int i = 1; i <= n; ++i) {
for (auto u : in[i]) {
for (auto v : G[u]) {
last[ans[v]] = u;
}
ans[u] = 1;
while (last[ans[u]] == u) {
++ans[u];
}
if (ans[u] != i) {
puts("-1");
exit(0);
}
result.push_back(u);
}
}
for (int i = 0; i < n; ++i) {
printf("%d%c", result[i], i == n - 1 ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAXN = 1010, MAXK = 60;
inline int add(int a, int b) {
int ret = a + b;
if (ret >= MOD) ret -= MOD;
return ret;
}
inline int mul(int a, int b) {
long long int ret = (long long int)a * b;
if (ret >= MOD) ret %= MOD;
return ret;
}
int dp[MAXN][MAXN][MAXK];
int binomial[2 * MAXN][2 * MAXN];
int faktorijel[MAXN];
void postavi() {
dp[0][0][0] = 1;
dp[0][0][1] = 1;
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++)
for (int k = 0; k < MAXK; k++) {
if (i - 1 >= 0) dp[i][j][k] = add(dp[i][j][k], dp[i - 1][j][k]);
if (i - 1 >= 0 && j - i >= 0 && k - 1 >= 0)
dp[i][j][k] = add(dp[i][j][k], dp[i - 1][j - i][k - 1]);
}
faktorijel[0] = 1;
for (int i = 1; i < MAXN; i++) faktorijel[i] = mul(faktorijel[i - 1], i);
}
int povrh(int n, int k) {
if (k > n) return 0;
if (n < 0 || k < 0) return 0;
if (n == k || k == 0) return 1;
int &ret = binomial[n][k];
if (ret != -1) return ret;
return ret = add(povrh(n - 1, k), povrh(n - 1, k - 1));
}
int x_brojeva_suma_y(int x, int y) { return povrh(y + x - 1, x - 1); }
int main() {
postavi();
memset(binomial, -1, sizeof(binomial));
int test;
scanf("%d", &test);
for (int br = 0; br < test; br++) {
int n, k;
scanf("%d %d", &n, &k);
int rj = 0;
n = n - (k - 1) - 1;
int sum = 0;
if (k >= MAXK) {
printf("0\n");
continue;
}
for (int i = 0; i <= n; i++) {
int val = mul(dp[MAXN - 1][i][k], faktorijel[k]);
sum = add(sum, val);
rj = add(rj, mul(sum, x_brojeva_suma_y(k, n - i)));
}
printf("%d\n", rj);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
void solve() {
int n, m;
std::cin >> n >> m;
std::vector<std::vector<int>> E(n);
for (int i = 0; i < m; ++i) {
int u, v;
std::cin >> u >> v;
--u, --v;
E[u].push_back(v);
E[v].push_back(u);
}
std::vector<bool> vis(n);
std::vector<int> fa(n), dep(n);
std::function<void(int)> dfs = [&](int u) {
vis[u] = true;
for (int v : E[u]) {
if (!vis[v]) {
fa[v] = u;
dep[v] = dep[u] + 1;
dfs(v);
}
}
};
fa[0] = -1, dep[0] = 0;
dfs(0);
int u = std::max_element(dep.begin(), dep.end()) - dep.begin();
int D = dep[u] + 1;
if (D >= (n + 1) / 2) {
std::cout << "PATH\n";
std::vector<int> ans;
for (int i = u; i != -1; i = fa[i]) {
ans.push_back(i);
}
std::cout << ans.size() << "\n";
for (int v : ans) {
std::cout << v + 1 << " ";
}
std::cout << "\n";
return;
}
std::vector<std::vector<int>> id(D);
for (int i = 0; i < n; ++i) {
id[dep[i]].push_back(i);
}
std::vector<std::pair<int, int>> ans;
for (int i = 0; i < D; ++i) {
for (int j = 0; j + 1 < (int)id[i].size(); j += 2) {
ans.emplace_back(id[i][j], id[i][j + 1]);
}
}
std::cout << "PAIRING\n";
std::cout << ans.size() << "\n";
for (auto p : ans) {
std::cout << p.first + 1 << " " << p.second + 1 << "\n";
}
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int T;
std::cin >> T;
while (T--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long f, w, h, pref[200005], suff[200005], sum, sum1;
long long BinPow(long long x, long long n) {
if (n == 0)
return 1LL;
else if (n == 1)
return x % mod;
else {
long long sum = BinPow(x, n / 2) % mod;
sum *= sum;
sum %= mod;
if (n % 2 != 0) sum *= x;
sum %= mod;
return sum;
}
}
long long C(long long k, long long n) {
if (k > n || n < 0 || k < 0) return 0;
return (((pref[n] * suff[k]) % mod) * suff[n - k]) % mod;
}
int main() {
cin.tie(0), ios::sync_with_stdio(0);
cin >> f >> w >> h;
if (h == 0) {
cout << "1";
return 0;
}
if (w == 0) {
if (f >= 1) cout << "1";
return 0;
}
if (f == 0) {
if (w > h)
cout << 1 << "\n";
else
cout << 0;
return 0;
}
pref[0] = 1, suff[0] = 1;
for (int i = 1; i <= f + w; i++) {
pref[i] = pref[i - 1] * i;
pref[i] %= mod;
}
for (int i = 1; i <= f + w; i++) suff[i] = BinPow(pref[i], mod - 2);
for (int i = 1; i <= f + w; i++) {
int a, b;
if (i % 2 != 0) {
a = i / 2;
b = i - a;
sum += (C(a - 1, f - 1) * C(b - 1, w + b - b * (h + 1) - 1)) % mod;
sum %= mod;
sum1 += (C(a - 1, f - 1) * C(b - 1, w - 1)) % mod;
sum %= mod;
sum1 %= mod;
b = i / 2;
a = i - b;
sum += (C(a - 1, f - 1) * C(b - 1, w + b - b * (h + 1) - 1)) % mod;
sum %= mod;
sum1 += (C(a - 1, f - 1) * C(b - 1, w - 1)) % mod;
sum1 %= mod;
} else {
a = i / 2;
b = i - a;
sum += (2 * (C(a - 1, f - 1) * C(b - 1, w + b - b * (h + 1) - 1)) % mod) %
mod;
sum %= mod;
sum1 += (2 * (C(a - 1, f - 1) * C(b - 1, w - 1)) % mod) % mod;
sum1 %= mod;
}
}
cout << sum * BinPow(sum1, mod - 2) % mod;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, INF = 1e9;
struct T {
int l, r, d[3], mn[3], mx[3];
} t[N];
int n, m, q, a, b, c, lx, rx, ly, ry, lz, rz, rt, h[N], D;
inline bool cmp(int a, int b) { return t[a].d[D] < t[b].d[D]; }
inline void update(int x) {
int l = t[x].l, r = t[x].r;
for (int i = 0; i < 3; i++) {
t[x].mn[i] = t[x].mx[i] = t[x].d[i];
if (l)
t[x].mn[i] = min(t[x].mn[i], t[l].mn[i]),
t[x].mx[i] = max(t[x].mx[i], t[l].mx[i]);
if (r)
t[x].mn[i] = min(t[x].mn[i], t[r].mn[i]),
t[x].mx[i] = max(t[x].mx[i], t[r].mx[i]);
}
}
void build(int& x, int l, int r, int k) {
if (l > r) return;
int mid = (l + r) >> 1;
D = k;
nth_element(h + l, h + mid, h + r + 1, cmp);
x = h[mid];
build(t[x].l, l, mid - 1, (k + 1) % 3);
build(t[x].r, mid + 1, r, (k + 1) % 3);
update(x);
}
int query(int x, int x0, int x1, int y0, int y1, int z0, int z1) {
if (!x) return 0;
if (x1 < t[x].mn[0] || x0 > t[x].mx[0] || y1 < t[x].mn[1] ||
y0 > t[x].mx[1] || z1 < t[x].mn[2] || z0 > t[x].mx[2])
return 0;
if (x0 <= t[x].d[0] && t[x].d[0] <= x1 && y0 <= t[x].d[1] &&
t[x].d[1] <= y1 && z0 <= t[x].d[2] && t[x].d[2] <= z1)
return 1;
return query(t[x].l, x0, x1, y0, y1, z0, z1) |
query(t[x].r, x0, x1, y0, y1, z0, z1);
}
int main() {
scanf("%d%d%d%d%d%d", &a, &b, &c, &n, &m, &q);
lx = ly = lz = INF;
for (int i = 1; i <= n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
lx = min(lx, x);
ly = min(ly, y);
lz = min(lz, z);
rx = max(rx, x);
ry = max(ry, y);
rz = max(rz, z);
}
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (x >= lx && x <= rx && y >= ly && y <= ry && z >= lz && z <= rz)
return puts("INCORRECT"), 0;
t[i].d[0] = x;
t[i].d[1] = y;
t[i].d[2] = z;
}
for (int i = 1; i <= m; i++) h[i] = i;
build(rt, 1, m, 0);
puts("CORRECT");
while (q--) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (x >= lx && x <= rx && y >= ly && y <= ry && z >= lz && z <= rz) {
puts("OPEN");
continue;
}
int x0 = min(lx, x), x1 = max(rx, x), y0 = min(ly, y), y1 = max(ry, y),
z0 = min(lz, z), z1 = max(rz, z);
if (query(rt, x0, x1, y0, y1, z0, z1))
puts("CLOSED");
else
puts("UNKNOWN");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 1e5 + 5;
int n, m, k;
struct point {
int x, y, z;
point(const int x_ = 0, const int y_ = 0, const int z_ = 0) {
x = x_;
y = y_;
z = z_;
}
void read() {
x = get();
y = get();
z = get();
}
friend bool operator<=(point a, point b) {
return a.x <= b.x && a.y <= b.y && a.z <= b.z;
}
} a[N], Lim;
struct addition {
int lx, rx, ly, ry;
int ty, id;
int z;
} ad[N * 3];
int s;
int ans[N];
void add(point L, point R, point u, int id) {
L.x = min(L.x, u.x);
L.y = min(L.y, u.y);
L.z = min(L.z, u.z);
R.x = max(R.x, u.x);
R.y = max(R.y, u.y);
R.z = max(R.z, u.z);
s++;
ad[s].ty = 2;
ad[s].lx = L.x, ad[s].rx = R.x, ad[s].ly = L.y, ad[s].ry = R.y;
ad[s].id = -id;
ad[s].z = L.z - 1;
s++;
ad[s].ty = 2;
ad[s].lx = L.x, ad[s].rx = R.x, ad[s].ly = L.y, ad[s].ry = R.y;
ad[s].id = id;
ad[s].z = R.z;
}
struct POINT {
int x, y;
POINT(const int x_ = 0, const int y_ = 0) { x = x_, y = y_; }
} num[N];
bool sig;
struct node {
int x, y, l, r;
int lx, rx, ly, ry;
int cnt, v;
} tree[N];
int rt, tot;
int fa[N];
bool cmp(POINT a, POINT b) {
if (sig) return a.x < b.x;
return a.y < b.y;
}
int build(int l, int r, bool sg) {
sig = sg;
int mid = (l + r) / 2;
int now = ++tot;
nth_element(num + l, num + mid, num + r + 1, cmp);
tree[now].x = num[mid].x;
tree[now].y = num[mid].y;
if (l < mid) tree[now].l = build(l, mid - 1, sg ^ 1);
if (mid < r) tree[now].r = build(mid + 1, r, sg ^ 1);
tree[now].lx = tree[now].rx = tree[now].x;
tree[now].ly = tree[now].ry = tree[now].y;
if (tree[now].l) {
int x = tree[now].l;
tree[now].lx = min(tree[now].lx, tree[x].lx);
tree[now].rx = max(tree[now].rx, tree[x].rx);
tree[now].ly = min(tree[now].ly, tree[x].ly);
tree[now].ry = max(tree[now].ry, tree[x].ry);
}
if (tree[now].r) {
int x = tree[now].r;
tree[now].lx = min(tree[now].lx, tree[x].lx);
tree[now].rx = max(tree[now].rx, tree[x].rx);
tree[now].ly = min(tree[now].ly, tree[x].ly);
tree[now].ry = max(tree[now].ry, tree[x].ry);
}
return now;
}
bool cp(addition a, addition b) { return a.z != b.z ? a.z < b.z : a.ty < b.ty; }
bool add(int now, int x, int y) {
if (tree[now].x == x && tree[now].y == y) {
tree[now].cnt++;
tree[now].v++;
return 1;
}
if (x < tree[now].lx || x > tree[now].rx || y < tree[now].ly ||
y > tree[now].ry)
return 0;
if (tree[now].l && add(tree[now].l, x, y)) {
tree[now].cnt++;
return 1;
}
if (tree[now].r && add(tree[now].r, x, y)) {
tree[now].cnt++;
return 1;
}
return 0;
}
int query(int now, int lx, int rx, int ly, int ry) {
if (lx <= tree[now].lx && tree[now].rx <= rx && ly <= tree[now].ly &&
tree[now].ry <= ry)
return tree[now].cnt;
if (rx < tree[now].lx || lx > tree[now].rx || ry < tree[now].ly ||
ly > tree[now].ry)
return 0;
int ret = 0;
if (lx <= tree[now].x && tree[now].x <= rx && ly <= tree[now].y &&
tree[now].y <= ry)
ret = tree[now].v;
if (tree[now].l) ret = ret + query(tree[now].l, lx, rx, ly, ry);
if (tree[now].r) ret = ret + query(tree[now].r, lx, rx, ly, ry);
return ret;
}
int main() {
Lim.read();
n = get();
m = get();
k = get();
point R = point(0, 0, 0), L = point(1e9, 1e9, 1e9);
for (int i = 1; i <= n; i++) {
point u;
u.read();
L.x = min(L.x, u.x);
L.y = min(L.y, u.y);
L.z = min(L.z, u.z);
R.x = max(R.x, u.x);
R.y = max(R.y, u.y);
R.z = max(R.z, u.z);
}
for (int i = 1; i <= m; i++) {
point u;
u.read();
a[i] = u;
if (L <= u && u <= R) return printf("INCORRECT\n"), 0;
}
printf("CORRECT\n");
for (int i = 1; i <= k; i++) {
point p;
p.read();
if (L <= p && p <= R)
ans[i] = -1;
else {
add(L, R, p, i);
}
}
for (int i = 1; i <= m; i++) {
num[i] = POINT(a[i].x, a[i].y);
s++;
ad[s].lx = a[i].x, ad[s].ly = a[i].y;
ad[s].z = a[i].z;
ad[s].ty = 1;
}
sig = 1;
rt = build(1, m, 1);
sort(ad + 1, ad + 1 + s, cp);
for (int i = 1; i <= s; i++)
if (ad[i].ty == 1) {
add(rt, ad[i].lx, ad[i].ly);
} else {
int id = ad[i].id;
if (id < 0)
ans[-id] = ans[-id] - query(rt, ad[i].lx, ad[i].rx, ad[i].ly, ad[i].ry);
else
ans[id] = ans[id] + query(rt, ad[i].lx, ad[i].rx, ad[i].ly, ad[i].ry);
}
for (int i = 1; i <= k; i++)
if (ans[i] < 0)
printf("OPEN\n");
else if (ans[i] == 0)
printf("UNKNOWN\n");
else
printf("CLOSED\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int rd() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') f = c == '-' ? -1 : 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
return x * f;
}
const int N = 3e5 + 10;
const int inf = 1e6 + 10;
map<int, int> mp;
int a[N], s1[N], s2[N], sum[N << 2], tag[N << 2];
int L, R, ans, n, K, d, top1, top2, k;
void modify(int k, int l, int r, int x, int y, int z) {
if (x == l && r == y) {
sum[k] += z, tag[k] += z;
return;
}
int mid = l + r >> 1;
if (y <= mid)
modify(k << 1, l, mid, x, y, z);
else if (x > mid)
modify(k << 1 | 1, mid + 1, r, x, y, z);
else
modify(k << 1, l, mid, x, mid, z),
modify(k << 1 | 1, mid + 1, r, mid + 1, y, z);
tag[k] = min(tag[k << 1], tag[k << 1 | 1]) + sum[k];
}
int query(int k, int l, int r, int x) {
if (l == r) return l;
int mid = l + r >> 1;
x -= sum[k];
if (tag[k << 1] <= x)
return query(k << 1, l, mid, x);
else
return query(k << 1 | 1, mid + 1, r, x);
}
int main() {
n = rd(), K = rd(), d = rd();
for (int i = 1; i <= n; i++) a[i] = rd() + 1e9 + 1;
L = R = ans = 1;
if (!d) {
for (int j, i = 1; i <= n; i = j + 1) {
for (j = i; j < n && a[j + 1] == a[i]; j++)
;
if (j - i + 1 > ans) ans = j - i + 1, L = i, R = j;
}
return printf("%d %d\n", L, R), 0;
}
modify(1, 1, n, 1, n, inf);
for (int i = 1; i <= n; i++) {
if (i != 1 && (a[i] - a[i - 1]) % d)
modify(1, 1, n, k + 1, i - 1, inf), k = i - 1;
if (mp[a[i]] > k) modify(1, 1, n, k + 1, mp[a[i]], inf), k = mp[a[i]];
mp[a[i]] = i;
while (top1 && a[s1[top1]] > a[i])
modify(1, 1, n, s1[top1 - 1] + 1, s1[top1], a[s1[top1]] / d - a[i] / d),
top1--;
while (top2 && a[s2[top2]] < a[i])
modify(1, 1, n, s2[top2 - 1] + 1, s2[top2], a[i] / d - a[s2[top2]] / d),
top2--;
s1[++top1] = s2[++top2] = i;
modify(1, 1, n, i, i, i - inf);
int j = query(1, 1, n, i + K);
if (i + L > R + j) L = j, R = i;
}
return printf("%d %d\n", L, R), 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 9;
set<int> ist;
map<string, int> msi;
map<string, string> mss;
map<int, string> mis;
map<int, int> mii;
pair<int, int> pii;
vector<int> v;
vector<pair<int, int> > vv;
int cc[] = {1, -1, 0, 0};
int rr[] = {0, 0, 1, -1};
void LIFT_OFF_SHARK_AP20() {
int t;
int a, b, c;
cin >> a >> b >> c;
for (int i = 0; i <= min(a, b); i++) {
int x = a - i;
int y = b - i;
if (x + y == c) {
cout << i << " " << y << " " << x << endl;
return;
}
}
cout << "Impossible" << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
LIFT_OFF_SHARK_AP20();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 1e6 + 6;
ll inv(ll a, ll m) { return a == 1 ? 1 : m - m * inv(m % a, a) / a; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int p;
ll a, b, x;
cin >> a >> b >> p >> x;
ll per = p * (p - 1LL);
ll pa = 1, ans = 0;
for (int i = 0; i < p - 1; ++i) {
ll n = b * inv(pa, p) % p;
ll d = ((i - n) % p + p) % p;
ll y = i + (p - 1) * d;
ll k = x < y ? 0 : (x - y) / per + 1;
ans += k;
pa = pa * a % p;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define Inf 1000000000000000000LL
#define LL long long
#define pb push_back
#define mp make_pair
#define F first
#define S second
using namespace std;
typedef pair<int,int>pii;
const int mod=1e9+7;
int n,a[100010];
vector<int>w;
string s;
LL pre[100010],sum[100010],dp[100010];
int f[100010],nxt[100010];
char c[100010],ans[100010];
void solve(int l,int r){
int dl=l,dr=r;
while(a[dl]==1&&dl<=r){
ans[dl]='+';
dl++;
}
while(a[dr]==1&&l<=dr){
ans[dr]='+';
dr--;
}
l=dl,r=dr;
if(l>r)return;
pre[l-1]=1;
sum[l-1]=0;
int flg=0;
for(int i=l;i<=r;i++){
pre[i]=pre[i-1]*a[i];
sum[i]=sum[i-1]+a[i];
if(pre[i]>Inf){
flg=1;
break;
}
}
if(flg){
for(int i=l;i<r;i++)ans[i]='*';
ans[r]='+';
return;
}
int now=l;
for(int i=l;i<=r;i++){
now=max(now,i);
while(a[now]==1&&now<=n)++now;
if(now==i)nxt[i]=now;
else nxt[i]=now-1;
}
for(int i=l-1;i<=r;i++)dp[i]=0;
for(int i=l-1;i<=r-1;i++){
for(int j=i+1;j<=r;j=max(j+1,nxt[j])){
if(pre[j]/pre[i]+dp[i]>dp[j]){
dp[j]=pre[j]/pre[i]+dp[i];
f[j]=i;
c[j]='*';
}
if(sum[j]-sum[i]+dp[i]>dp[j]){
dp[j]=sum[j]-sum[i]+dp[i];
f[j]=i;
c[j]='+';
}
}
}
now=r;
while(now!=l-1){
int x=f[now];
for(int i=x+1;i<now;i++)ans[i]=c[now];
ans[now]='+';
now=x;
}
}
int main(){
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i];
cin>>s;
int sz=s.size();
if(sz==1){
for(int i=1;i<n;i++)cout<<a[i]<<s[0];
cout<<a[n]<<endl;
}else if(s=="+-"||s=="-+"){
for(int i=1;i<n;i++)cout<<a[i]<<'+';
cout<<a[n]<<endl;
}else if(s=="+*"||s=="*+"||sz==3){
int l=1;
for(int i=1;i<=n;i++){
if(a[i]==0){
if(l<=i-1)solve(l,i-1);
ans[i]='+';
l=i+1;
}
}
if(l<=n)solve(l,n);
for(int i=1;i<n;i++)cout<<a[i]<<ans[i];
cout<<a[n]<<endl;
}else if(s=="-*"||s=="*-"){
cout<<a[1];
for(int i=2;i<=n;i++){
if(a[i-1]>0&&a[i]==0)cout<<'-';
else cout<<'*';
cout<<a[i];
}
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool f(string s, string t) {
long long int j = 0;
for (long long int i = 0; i < s.size(); i++) {
if (s[i] == t[j]) {
j++;
}
}
if (j == t.size()) {
return true;
} else {
return false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
string t = "heidi";
if (f(s, t)) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool borj(int n, int i) {
int a = pow(2, ((double)i));
int g = (a - 1) * a / 2;
if (n % g == 0) return true;
return false;
}
int main() {
int n;
int m = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
if (borj(n, i) == true) {
int a = pow(2, ((double)i));
int g = (a - 1) * a / 2;
if (m < g) m = g;
}
}
cout << m;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int MK = 37, MN = 1e5 + 10;
int dp[MK][MN], a, b, h, w, n;
int ext[MN], Ans = INF;
void solve() {
memset(dp, 0, sizeof dp);
dp[0][1] = 1;
for (int i = 0; i < n; ++i) {
for (int val = 1; val < MN; ++val) {
int F = min((long long)MN, 1ll * dp[i][val] * ext[i]);
dp[i + 1][val] = max(F, dp[i][(val + ext[i] - 1) / ext[i]]);
}
}
int t = (a + h - 1) / h;
for (int i = 1; i <= n; ++i) {
if (dp[i][t] >= (b + w - 1) / w) Ans = min(Ans, i);
}
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> a >> b >> h >> w >> n;
for (int i = 0; i < n; ++i) cin >> ext[i];
if ((h >= a && w >= b) || (h >= b && w >= a)) return cout << 0 << '\n', 0;
sort(ext, ext + n, greater<int>());
n = min(n, 34);
solve();
swap(a, b);
solve();
cout << (Ans >= INF ? -1 : Ans) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 111111;
pair<long long, long long> stud[N];
long long ttoi[N], ans[N];
set<long long> off[N];
long long n, m;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (long long i = (1); i <= (n); i++) {
long long t, x;
cin >> t >> x;
stud[i] = {t, x};
ttoi[t] = i;
}
vector<pair<long long, long long> > bus;
long long t = 0;
for (long long i = (1); i <= (n); i++) {
bus.push_back({stud[i].second, stud[i].first});
t = max(t, stud[i].first);
if (i % m == 0 || i == n) {
set<long long> post;
for (auto p : bus) {
off[p.first].insert(ttoi[p.second]);
post.insert(p.first);
}
long long cx = 0;
for (auto x : post) {
t += x - cx;
for (auto id : off[x]) {
ans[id] = t;
}
t += 1 + (long long)(off[x]).size() / 2;
cx = x;
off[x].clear();
}
t += cx;
bus.clear();
}
}
for (long long i = (1); i <= (n); i++) {
cout << ans[i] << " ";
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0, s = 2015;
printf("2000\n");
for (i = 1; i <= 1000; i++) printf("%d 1 %d 2\n", i, i);
for (i = 1000; i >= 1; i--) printf("%d 1 %d 2\n", i, i);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct tria {
int p[3];
} trias[100010];
vector<int> p2t[100010];
int i, j, n, m;
bool checked[100010];
int di[100010];
vector<pair<int, int> > que;
vector<int> ans;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
map<pair<int, int>, int> edgeC;
void addE(int a, int b) {
if (a > b) swap(a, b);
auto p = make_pair(a, b);
if (edgeC[p] == 0) {
edgeC[p] = 1;
} else {
edgeC[p]++;
}
}
vector<int> edges[100010];
void checkit(int a, int b) {
if (a > b) swap(a, b);
if (edgeC[make_pair(a, b)] == 1) {
edges[a].push_back(b);
edges[b].push_back(a);
}
}
int main() {
int ii;
scanf("%d", &ii);
while (ii--) {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
p2t[i].clear();
edges[i].clear();
}
edgeC.clear();
for (i = 1; i <= n - 2; i++) {
scanf("%d %d %d", &trias[i].p[0], &trias[i].p[1], &trias[i].p[2]);
addE(trias[i].p[0], trias[i].p[1]);
addE(trias[i].p[1], trias[i].p[2]);
addE(trias[i].p[0], trias[i].p[2]);
for (j = 0; j < 3; j++) {
p2t[trias[i].p[j]].push_back(i);
}
}
for (i = 1; i <= n - 2; i++) {
checkit(trias[i].p[0], trias[i].p[1]);
checkit(trias[i].p[1], trias[i].p[2]);
checkit(trias[i].p[0], trias[i].p[2]);
}
memset(di, 0, sizeof(di));
memset(checked, 0, sizeof(checked));
que.clear();
ans.clear();
for (i = 1; i <= n; i++) {
di[i] = (int)(p2t[i].size());
que.push_back(make_pair(di[i], i));
push_heap(que.begin(), que.end(), cmp);
}
i = 1;
checked[1] = true;
bool found = true;
printf("1");
while (found) {
found = false;
for (const auto e : edges[i])
if (!checked[e]) {
checked[e] = true;
printf(" %d", e);
found = true;
i = e;
break;
}
}
printf("\n");
memset(checked, 0, sizeof(checked));
while (que.size()) {
pop_heap(que.begin(), que.end(), cmp);
auto now_pair = que.back();
que.pop_back();
int now = now_pair.second;
if (di[now] != now_pair.first || di[now] == 0) continue;
if (di[now] != 1) {
printf("no %d %d\n", now, di[now]);
continue;
}
di[now] = 0;
int tr = 0;
for (const auto t : p2t[now]) {
if (!checked[t]) {
checked[t] = true;
tr = t;
break;
}
}
ans.push_back(tr);
int a = 0, b = 0;
for (i = 0; i < 3; i++) {
if (trias[tr].p[i] != now) {
di[trias[tr].p[i]]--;
que.push_back(make_pair(di[trias[tr].p[i]], trias[tr].p[i]));
push_heap(que.begin(), que.end(), cmp);
}
}
}
for (const auto a : ans) {
printf("%d ", a);
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, l;
deque<long long> a, pr, dp;
long long f[2048], C[2048][2048], mod = 1000000007;
int main(int argc, char const* argv[]) {
cin >> n;
f[0] = 1;
for (int i = 1; i <= n; i += 1) f[i] = ((f[i - 1] * ((long long)i)) % mod);
for (int i = 0; i <= n; i += 1) {
C[i][0] = 1;
C[i][i] = 1;
for (int j = 1; j < i; j += 1)
C[i][j] = ((C[i - 1][j] + C[i - 1][j - 1]) % mod);
}
a = deque<long long>(n + 1), pr = deque<long long>(n + 1, 0);
for (int i = 1; i <= n; i += 1) {
cin >> a[i];
if (a[i] != -1) pr[a[i]] = 1, k += 1;
}
for (int i = 1; i <= n; i += 1) l += (a[i] == -1 && pr[i] == 1);
n -= (k + l);
dp = deque<long long>(n + 1);
for (int s = 0; s <= n; s += 1) {
dp[s] = f[l + s];
for (int t = 1; t <= s; t += 1)
dp[s] = ((dp[s] + mod - ((C[s][t] * dp[s - t]) % mod)) % mod);
}
cout << dp[n] << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T GCD(T a, T b) {
long long t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T>
string toString(T a) {
return to_string(a);
}
template <typename T>
void toInt(string s, T &x) {
stringstream str(s);
str >> x;
}
inline int add(long long a, long long b) {
a += b;
if (a < 0) a += 1000000007;
return a;
}
inline int sub(long long a, long long b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
inline int mul(long long a, long long b) { return (a * 1ll * b) % 1000000007; }
inline int pwr(long long x, long long y) {
int ans = 1 % 1000000007;
while (y) {
if (y & 1) ans = mul(ans, x);
x = mul(x, x);
y >>= 1;
}
return ans;
}
inline int inv(int a) { return pwr(a, 1000000007 - 2); }
vector<int> aa;
int n, m;
vector<vector<int> > vec(501, vector<int>(501));
int dp[501][2000];
int fun(int ind, int cur) {
if (ind == n) {
if (cur > 0) {
cout << "TAK" << '\n';
for (auto it : aa) {
cout << it << " ";
}
cout << '\n';
exit(0);
} else {
return 0;
}
}
if (dp[ind][cur] != -1) {
return dp[ind][cur];
}
int ans = 0;
for (int i = 0; i < m; i++) {
aa.push_back(i + 1);
ans = fun(ind + 1, (cur ^ vec[ind][i]));
aa.pop_back();
}
dp[ind][cur] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
int x = 0, v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> v;
vec[i][j] = v;
}
}
memset(dp, -1, sizeof(dp));
fun(0, 0);
cout << "NIE" << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i = 0, x = -1, ans = 0;
while (i < s.length()) {
if (s[i] % 3 == 0) {
x = i;
ans++;
} else {
int j = i, sum = 0;
while (j > x) {
sum += s[j];
if (sum % 3 == 0) {
j = x;
x = i;
ans++;
}
j--;
}
}
i++;
}
cout << ans << endl;
}
| 3 |
#include<bits/stdc++.h>
#define ll long long
#define Il inline
#define Re register
#define mem(u,v) memset(u,v,sizeof(u))
#define rep(i,a,b) for(Re ll i=(a);i<=(b);i++)
#define drep(i,a,b) for(Re ll i=(a);i>=(b);i--)
#define go(u) for(ll i=head[u],v=e[i].to;i;i=e[i].nxt,v=e[i].to)
#define writesp(x) write(x),putchar(' ')
#define writeln(x) write(x),puts("")
using namespace std;
Il ll read(){ll sum=0,f=0;char ch=getchar();for(;!isdigit(ch);ch=getchar())f|=(ch=='-');for(;isdigit(ch);ch=getchar())sum=((sum<<1)+(sum<<3)+(ch^48));return f?-sum:sum;}
void write(const ll x){if(x<0){putchar('-');write(-x);return;}if(x>9)write(x/10);putchar(x%10+'0');}
#define N 1100000
ll n,m;bool b[2200];
int main(){
n=read();m=read();
while(n){
if(b[n%m])return puts("NO");
b[n%m]=1;
n/=m;
}
puts("YES");
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
const int MOD = 998244353;
const int INF = 1e9 + 7;
char s[MAX];
long long n, m, L;
long long sum[MAX];
pair<long long, long long> d[MAX];
long long cal(long long val) {
d[0] = {0, 0};
for (int i = 1; i <= n; i++) {
d[i] = d[i - 1];
d[i].first += sum[i];
if (i > L)
d[i] = min(d[i], {d[i - L].first + val, d[i - L].second + 1});
else
d[i] = min(d[i], {val, 1});
}
return d[n].second;
}
long long solve(int tag) {
for (int i = 1; i <= n; i++) sum[i] = tag ^ ('A' <= s[i] && s[i] <= 'Z');
long long l = 0, r = n;
while (r >= l) {
long long mid = (l + r) / 2;
if (cal(mid) > m)
l = mid + 1;
else
r = mid - 1;
}
cal(l);
return d[n].first - l * m;
}
int main() {
cin >> n >> m >> L;
scanf("%s", s + 1);
cout << min(solve(1), solve(0)) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 5e5 + 30;
const int INF = 1e9 + 7;
class codeforces {
public:
void solve();
};
map<pair<int, int>, int> m;
void codeforces ::solve() {
int n, r1, c1, r2, c2;
cin >> n >> r1 >> c1 >> r2 >> c2;
pair<int, int> p;
for (int i = 0; i < 4 * n; ++i) {
if (i < (2 * n)) {
p.second = min(n, i);
p.first = (i - p.second);
m.insert(make_pair(p, i));
} else {
int j = (4 * n) - i;
p.first = min(n, j);
p.second = (j - p.first);
m.insert(make_pair(p, i));
}
}
int a, b;
p = make_pair(r1, c1);
a = m[p];
p = make_pair(r2, c2);
b = m[p];
int dist = abs(a - b);
cout << min(dist, (4 * n) - dist) << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int T = 1;
while (T--) {
codeforces problem;
problem.solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
bool color[27];
char board[101][101], str[120];
int n, m, tmp;
char pres, ent;
int cnt = 0;
for (int i = 0; i < 27; i++) color[i] = false;
scanf("%d %d %c", &n, &m, &pres);
scanf("%c", &ent);
while (ent != '\n') scanf("%c", &ent);
for (int i = 0; i < n; i++) {
scanf("%s", str);
for (int j = 0; j < m; j++) board[i][j] = str[j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (board[i][j] == pres) {
if ((i > 0) && (board[i - 1][j] != '.') && (board[i - 1][j] != pres)) {
tmp = board[i - 1][j] - 'A';
if (!color[tmp]) {
color[tmp] = true;
cnt++;
}
}
if ((i < n - 1) && (board[i + 1][j] != '.') &&
(board[i + 1][j] != pres)) {
tmp = board[i + 1][j] - 'A';
if (!color[tmp]) {
color[tmp] = true;
cnt++;
}
}
if ((j > 0) && (board[i][j - 1] != '.') && (board[i][j - 1] != pres)) {
tmp = board[i][j - 1] - 'A';
if (!color[tmp]) {
color[tmp] = true;
cnt++;
}
}
if ((j < m - 1) && (board[i][j + 1] != '.') &&
(board[i][j + 1] != pres)) {
tmp = board[i][j + 1] - 'A';
if (!color[tmp]) {
color[tmp] = true;
cnt++;
}
}
}
}
printf("%d\n", cnt);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 10 or n >= 22)
cout << 0;
else if (n >= 11 and n != 20)
cout << 4;
else
cout << 15;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
vector<pair<int, int>> b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i].first = a[i];
b[i].second = i;
}
sort(b.begin(), b.end());
for (int i = 1; i < n; i++) {
if (b[i].first == b[i - 1].first) {
cout << "YES\n";
return;
}
}
vector<int> pos(n);
for (int i = 0; i < n; i++) {
a[b[i].second] = i;
}
for (int i = 0; i < n; i++) {
pos[a[i]] = i;
}
for (int i = 0; i < n - 2; i++) {
if (a[i] == i)
continue;
else if (a[i] != n - 1 && a[i] != n - 2) {
pos[a[i]] = pos[n - 1];
pos[n - 1] = pos[i];
a[pos[n - 1]] = n - 1;
a[pos[a[i]]] = a[i];
} else if (a[i] == n - 1) {
pos[n - 1] = pos[n - 2];
pos[n - 2] = pos[i];
a[pos[n - 1]] = n - 1;
a[pos[n - 2]] = n - 2;
} else if (a[i] == n - 2) {
pos[n - 2] = pos[n - 1];
pos[n - 1] = pos[i];
a[pos[n - 1]] = n - 1;
a[pos[n - 2]] = n - 2;
}
}
if (pos[n - 1] == n - 1) {
cout << "YES\n";
} else
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
long long in() {
long long x;
cin >> x;
return x;
}
int In() {
int x;
cin >> x;
return x;
}
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
int ca = 0, cb = 0;
for (long long i = 0; i < n; i++) {
long long ca = 0, cb = 0;
for (long long j = i; j < n; j++) {
if (s[j] == 'a') {
ca++;
} else {
cb++;
}
if (ca == cb && ca != 0 && cb != 0) {
cout << i + 1 << " " << j + 1 << '\n';
return;
}
}
}
cout << -1 << " " << -1 << '\n';
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = -n; i <= n; i++) {
int upto = n - abs(i);
for (int j = 0; j < 2 * n - 2 * upto; j++) {
cout << " ";
}
for (int j = -upto; j <= upto; j++) {
cout << upto - abs(j) << "\n "[j < upto];
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const int MOD = 1000000007;
int pd[2003][2003];
long long v[2003];
int n, h;
int solve1(int p, int c) {
if (p == n) return c == 0;
if (pd[p][c] == -1) {
long long ans = 0;
if (v[p] + c == h) {
ans = (ans + solve1(p + 1, c)) % MOD;
if (c > 0) ans = (ans + c * (long long)solve1(p + 1, c - 1)) % MOD;
}
if (v[p] + c + 1 == h) {
ans = (ans + solve1(p + 1, c + 1)) % MOD;
ans = (ans + (c + 1) * (long long)solve1(p + 1, c)) % MOD;
}
pd[p][c] = ans;
}
return pd[p][c];
}
int solve0() {
memset(pd, -1, sizeof pd);
int ans = solve1(0, 0);
return ans;
}
int main() {
while (cin >> n >> h) {
for (int i = 0; i < n; ++i) cin >> v[i];
cout << solve0() << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1050;
long long p1, p2, v1, v2, x, sz, Num, R1S, R1E, R2S, R2E, R3S, R3E, R4S, R4E,
arr[N];
double All, Good;
bool Valid1, Valid2, Valid3, Valid4, Same;
void Go(int length) {
if (length > 9) return;
arr[sz++] = Num;
Num *= 10;
Num += 4, Go(length + 1);
Num += 3, Go(length + 1);
Num /= 10;
}
void Prepare_Lucky_Numbers() {
Go(0);
arr[sz++] = 1000000000;
sort(arr, arr + sz);
}
int main() {
Prepare_Lucky_Numbers();
scanf("%I64d %I64d %I64d %I64d %I64d", &p1, &p2, &v1, &v2, &x);
All = (p2 - p1 + 1) * (v2 - v1 + 1);
for (int i = 1; i < sz - x; i++) {
long long St1 = arr[i - 1] + 1, En1 = arr[i], St2 = arr[i + x - 1],
En2 = arr[i + x] - 1, tmp = 0;
R1S = max(p1, St1), R1E = min(En1, p2), Valid1 = (R1S <= R1E);
R2S = max(v1, St1), R2E = min(En1, v2), Valid2 = (R2S <= R2E);
R3S = max(p1, St2), R3E = min(En2, p2), Valid3 = (R3S <= R3E);
R4S = max(v1, St2), R4E = min(En2, v2), Valid4 = (R4S <= R4E);
if (Valid1 && Valid4) {
tmp += (R1E - R1S + 1) * (R4E - R4S + 1);
}
if (Valid2 && Valid3) {
tmp += (R2E - R2S + 1) * (R3E - R3S + 1);
}
if (R2E == R3S && R1E == R4S && R1E == R2E) tmp--;
Good += tmp;
}
printf("%.12lf", Good / All);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
void precalc(int n) {
static int dp[257][257][257], C[257][257];
dp[0][0][0] = 1;
for (int i = 0; i < 257; i++)
for (int j = 0; j <= i; j++) {
if (j == 0 || i == j)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 777777777;
}
const long long mod = (long long)777777777 * 777777777 * 5;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= j; k++) {
long long mid = 0;
for (int r = 0, ed = min(i, k + 1); r < ed; r++) {
mid += (long long)dp[i - 1][j - r][k - r] * C[n - j + r][r];
if (mid >= mod) mid -= mod;
}
for (int r = i + 1; r <= k; r++) {
mid += (long long)dp[i - 1][j - r][k - r] * C[n - j + r][r];
if (mid >= mod) mid -= mod;
}
if (j >= i) mid += (long long)dp[i - 1][j - i][k] * C[n - j + i][i];
dp[i][j][k] = mid % 777777777;
}
}
}
putchar('{');
for (int i = 0; i <= n; i++) {
if (i) putchar(',');
print(dp[n][n][i]);
}
putchar('}');
putchar(',');
puts("");
}
int res[11][257] = {
{1, 0},
{1, 2, 1},
{5, 32, 30, 80, 109},
{541, 6824, 59808, 147224, 415870, 1757896, 1897056, 4898872, 7593125},
{166257661, 776830421, 290516100, 746623577, 293783147, 33900006, 735127505,
565460332, 428982705, 472062098, 161873957, 117354594, 515619293,
578944191, 312106242, 569389279, 391464593},
{464207287, 261086313, 584837659, 683961846, 468868529, 211593382,
736955478, 229471758, 157617135, 398169441, 360252438, 629394768,
264125799, 647490480, 342079395, 391579767, 225200475, 486011304,
513156108, 628771752, 132906648, 142138221, 20119449, 444199674,
195188679, 387329805, 44684703, 651912135, 737154512, 612549793,
519860281, 186175544, 212568440},
{382725349, 240805271, 239509872, 581127897, 6511239, 156126222,
509425833, 672407328, 366667722, 459185405, 509737025, 554790222,
165216555, 703150560, 74806569, 398730015, 383350905, 506108358,
51326142, 298053147, 104256117, 391428765, 374020479, 206607807,
87664059, 275899176, 56407680, 551553401, 448939463, 582889860,
129676638, 226078251, 135769095, 61292868, 578972226, 190181628,
390739055, 184587732, 446575689, 732674124, 232198470, 676760679,
352474101, 611444862, 575661807, 628905585, 320813094, 522840969,
469781928, 156006018, 554473341, 239654268, 643714911, 433540170,
199307003, 496385218, 291740751, 67309914, 370826673, 202356819,
279421821, 421203111, 63744786, 520987612, 550671827},
{642497124, 482164403, 768209115, 462063756, 154906374, 36099042,
341766705, 678182556, 621882744, 478771358, 231881111, 175889805,
243630450, 168908523, 671961765, 55761813, 652682670, 773939082,
517628076, 756201264, 124604900, 750976272, 498253248, 676047609,
137170026, 705610017, 495032139, 561797418, 703097347, 500815609,
95984586, 739707108, 265613565, 387099846, 777331779, 594676173,
591219559, 407997044, 208947235, 93337440, 478908360, 685013007,
487033953, 671903001, 39521181, 738490312, 33785059, 465470131,
310453920, 54648783, 346831137, 427694175, 474743430, 705296781,
435828036, 429824745, 663532359, 261388683, 244690731, 533997135,
596108961, 506813013, 371892402, 590145264, 104733162, 143420103,
654339672, 700348950, 685038942, 578826927, 286484229, 501639192,
434962491, 299270097, 27702486, 335375775, 111746817, 565603164,
294926121, 676063665, 735862995, 710035809, 437011960, 668528077,
138765186, 508213986, 615036450, 353784942, 624827616, 343900011,
241289776, 52410890, 72018835, 352406796, 415705878, 4802637,
376367145, 65589678, 333633477, 341834527, 303717460, 282387700,
42951006, 254706039, 423048528, 526429710, 68131467, 669954708,
12787348, 500636381, 317959019, 479433192, 657133515, 416259390,
610216692, 340129188, 44594256, 257373347, 138718678, 530767740,
292922628, 37220268, 605295159, 480722613, 458170419, 30540300,
487159055, 232966794, 149150650},
{507720408, 412133651, 386543325, 139952108, 289303402, 102404925,
317067177, 396414708, 80515854, 663739304, 317300809, 228877044,
493725043, 715317967, 490300965, 315527373, 743539734, 488329191,
553627998, 533025234, 242583957, 706116537, 614109258, 645447222,
523195911, 492109128, 722623041, 111085128, 766395126, 654378921,
691964847, 496688157, 399056049, 654363234, 102052314, 191720088,
473910948, 259736526, 332840025, 388047555, 665791056, 627111387,
139696515, 441456687, 443032569, 283264821, 771641703, 452641455,
511306362, 117572859, 127701891, 721298331, 176520078, 357242229,
611296308, 696994956, 405628839, 429224274, 465336054, 695091546,
689828796, 574648641, 351220905, 507964023, 675326610, 517248963,
453528621, 220301928, 494463186, 681789969, 339589656, 44524053,
417125457, 339589404, 747135963, 341780733, 734158215, 396817281,
21997836, 5728464, 147611205, 456248898, 714128667, 377654949,
3862068, 128418948, 589390074, 304947090, 11703825, 228266073,
127304142, 429215724, 361541124, 521572968, 468358191, 341231688,
65323503, 613778508, 15985323, 291661029, 410970006, 591638112,
349541550, 89967528, 224922159, 361094166, 584206074, 640051812,
324264456, 652625388, 693768537, 11740617, 309238398, 211085469,
194905872, 639416484, 110110707, 296645895, 748118511, 131177718,
511142751, 775975599, 421403409, 475528473, 434685258, 1768977,
80301375, 708023862, 569195676, 56238084, 632887668, 88089750,
631539342, 396695565, 38780154, 695798271, 469819224, 439587099,
69045921, 682966116, 112310856, 64943298, 534475872, 40215357,
389728458, 286368453, 736006257, 501181650, 54829908, 603489402,
338032656, 512182818, 627500097, 462674016, 3103092, 157324491,
43978329, 596818971, 259025598, 9088632, 91991781, 577291428,
211245489, 429471231, 142626330, 172560633, 510907446, 444609585,
758102058, 375112647, 744786693, 276174402, 19259856, 233672418,
745389414, 225772848, 23385663, 324290610, 519804558, 120337812,
402578568, 360676008, 450089262, 551043738, 337388940, 512108856,
28879011, 690040638, 106017282, 558262341, 99972432, 608226003,
612152037, 42414435, 776201013, 39580443, 518796945, 494437752,
583194366, 723936555, 415359657, 309569589, 751104774, 166684527,
249229170, 353120823, 130668327, 753823584, 580966092, 561963717,
543672234, 393846327, 586278000, 327398400, 278403867, 156455586,
363920382, 190245195, 290039148, 547014447, 466218648, 146037150,
585462906, 666008595, 691786683, 374707494, 622498779, 231158277,
685740951, 115612245, 681825249, 545555745, 551718468, 277206615,
640171035, 757727334, 195193908, 658656684, 457760646, 225925875,
505761984, 18685233, 506832921, 112511021, 396846646, 290147622,
113924623, 669986155, 336008070, 63611061, 238586775, 119956662,
616557739, 772784623, 334527774, 410403148, 51933421},
};
int main() {
int n, k;
gn(n, k);
println(res[(__builtin_ctz(n))][k]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 200005;
int n;
vector<int> g[N];
int par[N], par2[N], dis[N];
int deg[N];
int sub[N];
void calc_sub(int v, int p = 0) {
sub[v] = 1;
for (int i : g[v]) {
if (i == p) continue;
calc_sub(i, v);
sub[v] += sub[i];
}
}
int centroid(int v, int p = 0) {
for (int i : g[v]) {
if (i != p && sub[i] > n / 2) {
return centroid(i, v);
}
}
return v;
}
vector<pair<int, int>> s[N];
bool cmp(vector<pair<int, int>> a, vector<pair<int, int>> b) {
return a.size() > b.size();
}
int where[N], where2[N];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n;
if (n == 2) {
cout << "2\n2 1" << endl;
return 0;
}
for (int i = 1, a, b; i < n; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
deg[a]++;
deg[b]++;
}
calc_sub(1);
int rt = centroid(1);
queue<int> q;
q.push(rt);
vector<int> ord;
while (!q.empty()) {
int cur = q.front();
q.pop();
ord.push_back(cur);
for (int i : g[cur]) {
if (i != par[cur]) {
par[i] = cur;
dis[i] = dis[cur] + 1;
if (cur == rt)
par2[i] = i;
else
par2[i] = par2[cur];
q.push(i);
}
}
}
reverse(ord.begin(), ord.end());
vector<int> used(n + 1, 0), pos(n + 1, 0);
vector<int> mp(n + 1, 0);
int nxt = 0;
for (int i = 1; i <= n; i++) {
if (i == rt || mp[par2[i]]) continue;
mp[par2[i]] = nxt++;
}
for (int i = 1; i <= n; i++) {
if (i != rt) {
s[mp[par2[i]]].push_back({dis[i], i});
}
}
sort(s, s + nxt, cmp);
s[nxt++].push_back({0, rt});
long long res = 0;
int ne = 1;
for (int i = 0; i < nxt - 1; i++) {
while (where[i] < (int)s[i].size()) {
int cnt = 0;
while (ne == i || where2[ne] == (int)s[ne].size()) {
cnt++;
ne = (ne + 1) % nxt;
}
pos[s[i][where[i]].second] = s[ne][where2[ne]].second;
res += (s[i][where[i]].first + s[ne][where2[ne]].first);
where[i]++;
where2[ne]++;
}
}
ne = 0;
int cnt = 0;
while (ne < nxt - 1 && where2[ne] == (int)s[ne].size()) {
ne++;
}
if (ne < nxt - 1) {
pos[rt] = s[ne][where2[ne]].second;
res += (s[ne][where2[ne]].first);
}
if (pos[rt] == 0) {
int x = -1;
for (int j : g[rt]) {
if ((int)g[j].size() > 1) {
x = j;
break;
}
}
if (x == -1) {
int a = g[rt][0], b = g[rt][1];
pos[rt] = a;
pos[a] = b;
pos[b] = rt;
} else {
int to = pos[x];
pos[x] = rt;
pos[rt] = to;
}
}
cout << res << endl;
for (int i = 1; i <= n; i++) {
cout << pos[i] << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, s;
cin >> n >> s;
vector<vector<long long>> tree(n + 1);
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
long long leaf = 0;
for (long long i = 1; i <= n; i++) {
if (tree[i].size() == 1) leaf++;
}
float answer = (2.0 * s) / leaf;
printf("%.10f\n", answer);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
const long double PI = 3.14159265358979323846;
const long long MOD = 1e+9 + 7;
const long long INF = LLONG_MAX;
const int INFi = INT_MAX;
const long long N = 2e+5 + 8;
vector<long long> adj[N];
long long vis[N];
long long dx4[] = {0, 1, 0, -1}, dy4[] = {1, 0, -1, 0};
long long test_cases = 1;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
;
long long n, m, a[N][5];
void MAIN(long long tc) {
long long ok = 0;
long long en = 0;
long long row = 1;
cin >> n >> m;
for (long long i = (1); i <= m; i++) {
if (ok == 0) {
if (en == 0) {
a[row][1] = i;
} else {
a[row][2] = i;
}
} else {
if (en == 0) {
a[row][4] = i;
} else {
a[row][3] = i;
}
row++;
}
ok ^= 1;
if (row > n) {
row = 1;
en = 1;
}
}
vector<long long> v;
for (long long i = (1); i <= n; i++) {
for (auto j : {2, 1, 3, 4}) {
if (a[i][j] != 0) {
v.push_back(a[i][j]);
}
}
}
for (auto it : v) cout << it << " ";
cout << "\n";
;
;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout << setprecision(10);
;
for (long long i = (1); i <= test_cases; i++) {
MAIN(i);
}
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.