solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
int const maxn = 50;
unsigned long long p10[20];
unsigned long long f[maxn][maxn];
int from[maxn][maxn];
int n;
std::string s;
void print() {
std::string s;
for (int i = 2 * n, j = n; i; j = from[i--][j])
if (from[i][j] == j)
s = s + "H";
else
s = s + "M";
std::cout << s << '\n';
}
int main() {
std::ios::sync_with_stdio(false);
p10[0] = 1;
for (int i = 1; i < 20; i++) p10[i] = p10[i - 1] * 10;
std::cin >> n;
std::cin >> s;
for (int i = 1; i <= 2 * n; i++) {
int tn = s[2 * n - i] - '0';
for (int j = std::max(i - n, 0); j <= std::min(n, i); j++) {
if (j > 0) {
auto tmp = f[i - 1][j - 1] + tn * p10[j - 1];
if (tmp >= f[i][j]) {
f[i][j] = tmp;
from[i][j] = j - 1;
}
}
if (i - 1 >= j && j >= i - 1 - n) {
auto tmp = f[i - 1][j] + tn * p10[i - j - 1];
if (tmp >= f[i][j]) {
f[i][j] = tmp;
from[i][j] = j;
}
}
}
}
print();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void prepare() {}
void solve() {
int n, w, m;
cin >> n >> w >> m;
double k = (n * w + .0) / m;
vector<int> used(n);
vector<vector<pair<int, double> > > v(m);
vector<double> q(m);
double eps = 1e-6;
int j = 0;
double t = w;
bool flag = true;
for (int i = 0; i < m && flag; ++i) {
while ((k - q[i]) > eps) {
if (t < eps) {
j++;
t = w;
}
if (used[j] == 2) flag = false;
double p = min(t, k - q[i]);
t -= p;
q[i] += p;
v[i].push_back(make_pair(j + 1, p));
used[j]++;
}
}
if (flag) {
cout << "YES" << endl;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < v[i].size(); ++j) {
cout << v[i][j].first << " ";
printf("%.6lf ", v[i][j].second);
}
cout << endl;
}
} else
cout << "NO";
}
int main() {
prepare();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n;
int a[N], belong[N];
char s[4][N >> 1];
int c[2][N], num[2];
void query(int *a, int n, char *s1, char *s2) {
if (n < 2) return;
printf("Q %d", n >> 1);
for (int i = 1; i < n; i += 2) printf(" %d %d", a[i], a[i + 1]);
putchar('\n');
fflush(stdout);
scanf("%s", s1 + 1);
if (n < 3) return;
printf("Q %d", (n - 1) >> 1);
for (int i = 2; i < n; i += 2) printf(" %d %d", a[i], a[i + 1]);
putchar('\n');
fflush(stdout);
scanf("%s", s2 + 1);
}
void print() {
int cnt[3] = {};
for (int i = 1; i <= n; ++i) ++cnt[a[i]];
printf("A %d %d %d\n", cnt[0], cnt[1], cnt[2]);
for (int i = 0; i < 3; ++i) {
for (int j = 1; j <= n; ++j)
if (a[j] == i) printf("%d ", j);
putchar('\n');
}
fflush(stdout);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
if (n == -1) return 0;
for (int i = 1; i <= n; ++i) a[i] = i;
query(a, n, s[0], s[1]);
a[0] = -1;
a[1] = 0;
for (int i = 2; i <= n; ++i)
a[i] = s[i & 1][i >> 1] == '1' ? a[i - 1] : a[i - 1] ^ 1;
num[0] = num[1] = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] != a[i - 1]) {
c[a[i]][++num[a[i]]] = i;
belong[i] = i;
} else
belong[i] = belong[i - 1];
}
assert(num[0] == num[1] || num[0] == num[1] + 1);
for (int i = 0; i < 2; ++i) query(c[i], num[i], s[i << 1], s[i << 1 | 1]);
for (int i = 2; i <= num[0]; ++i)
for (int j = 0; j < 2; ++j)
if (i <= num[j])
a[c[j][i]] =
s[j << 1 | i & 1][i >> 1] == '1'
? a[c[j][i - 1]]
: 3 - a[c[j][i - 1]] - (j ? a[c[0][i]] : a[c[1][i - 1]]);
for (int i = 1; i <= n; ++i) a[i] = a[belong[i]];
print();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> f;
long long fib[100] = {0};
int solve(long long n) {
int what[100] = {0};
int ind = -1;
for (int i = 90; i >= 0; i--) {
if (n >= fib[i]) {
n -= fib[i], what[i] = true;
if (ind == -1) ind = i;
}
}
vector<int> x, y;
x.push_back(1);
y.push_back(0);
int zero = 0, f = 1;
for (int i = 0; i <= ind; i++) {
if (what[i] == 0)
zero++;
else {
int z1 = (zero / 2) * (x.back() + y.back());
if (zero & 1 && !f) z1 += x.back();
int z2 = x.back() + y.back();
x.push_back(z1);
y.push_back(z2);
zero = 0;
f = false;
}
}
return x.back() + y.back();
}
int main() {
fib[0] = 1;
fib[1] = 2;
for (int i = 2; i <= 90; i++) fib[i] = fib[i - 1] + fib[i - 2];
int T;
long long n;
cin >> T;
while (T--) {
cin >> n;
cout << solve(n) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 60;
const int N = 100005;
int tree[N * 4][MAXV + 5], leaf[N];
int a[N];
void combine(int nd) {
int cc = nd << 1;
for (int i = 0; i < MAXV; i++)
tree[nd][i] = tree[cc][i] + tree[cc ^ 1][(tree[cc][i] + i) % MAXV];
}
void build(int nd, int le, int ri) {
if (le == ri) {
for (int i = 0; i < MAXV; i++)
if (i % a[le] == 0)
tree[nd][i] = 2;
else
tree[nd][i] = 1;
leaf[le] = nd;
return;
}
int mi = (le + ri) >> 1;
int cc = nd << 1;
build(cc, le, mi);
build(cc ^ 1, mi + 1, ri);
combine(nd);
}
void update(int id, int val) {
if (a[id] == val) return;
a[id] = val;
int nd = leaf[id];
for (int i = 0; i < MAXV; i++)
if (i % val == 0)
tree[nd][i] = 2;
else
tree[nd][i] = 1;
nd >>= 1;
while (nd > 0) {
combine(nd);
nd >>= 1;
}
}
pair<int, int> query(int nd, int le, int ri, int tr, int ph, int val) {
if (le > ph || ri < tr) return {0, 0};
if (tr <= le && ri <= ph) {
return {tree[nd][val], (val + tree[nd][val]) % MAXV};
}
int mi = (le + ri) >> 1;
int cc = nd << 1;
auto p = query(cc, le, mi, tr, ph, val);
auto p2 = query(cc ^ 1, mi + 1, ri, tr, ph, p.second);
return {p.first + p2.first, p2.second};
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
build(1, 1, n);
int q;
scanf("%d", &q);
while (q--) {
int x, y;
char code[10];
scanf("%s", code);
scanf("%d%d", &x, &y);
if (code[0] == 'A') {
printf("%d\n", query(1, 1, n, x, y - 1, 0));
} else {
update(x, y);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int inf = 1e9 + 10;
const long double Pi = 3.14159265;
int a[N], n, ans;
set<pair<int, int>> s, second;
void solve() {
cin >> n;
int j = 1, cur = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n + 1; i++) {
if (a[i] != cur and i > 1)
s.insert({-(i - j), j}), second.insert({j, i - j}), j = i, cur = a[i];
if (cur == 0) cur = a[i];
}
while (s.empty() == 0) {
ans++;
auto X = s.begin();
int len = -(*X).first, l = (*X).second;
s.erase(X);
second.erase({l, len});
auto i = second.lower_bound({l, len}), j = second.upper_bound({l, len});
if (i != second.end() and j != second.begin()) {
j--;
auto x = *i, y = *j;
if (a[x.first] == a[y.first]) {
second.erase(i), second.erase(j);
int length = x.second + y.second;
second.insert({y.first, length});
s.erase(s.find({-(x.second), x.first}));
s.erase(s.find({-(y.second), y.first}));
s.insert({-length, y.first});
}
}
}
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
int xx = 0;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, m, g[N][N], ind[N], out[N], v[N], p[N];
void init() {
memset(g, 0, sizeof(g));
memset(ind, 0, sizeof(ind));
memset(out, 0, sizeof(out));
int a, b;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
g[a][b] = 1;
out[a]++;
ind[b]++;
}
}
bool find(int r, int u) {
for (int i = 1; i <= n; i++) {
if (i == r || !g[u][i]) continue;
if (v[i]) continue;
v[i] = 1;
if (p[i] == -1 || find(r, p[i])) {
p[i] = u;
return true;
}
}
return false;
}
int handle(int r) {
int ans = 0;
memset(p, -1, sizeof(p));
for (int i = 1; i <= n; i++) {
if (i == r) continue;
memset(v, 0, sizeof(v));
if (find(r, i)) ans++;
}
return ans;
}
int solve(int r) {
int s = ind[r] + out[r] - g[r][r];
int ans = 2 * n - 1 - s;
int f = handle(r);
ans = ans + m - s - f;
ans = ans + n - 1 - f;
return ans;
}
int main() {
init();
int ans = 1 << 30;
for (int i = 1; i <= n; i++) ans = min(ans, solve(i));
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s, s1;
int main() {
int i, j, q, y = 0, ans = 15, res = 0;
cin >> s;
for (i = 1; i <= 45000; i++) {
q = i * i;
s1 = to_string(q);
int cnt = 0;
for (int j = 0; j < s.size(); j++) {
if (s[j] == s1[cnt]) cnt++;
}
y = s.size() - s1.size();
if (cnt == s1.size()) {
ans = min(ans, y);
}
}
if (ans == 15) {
cout << "-1" << endl;
} else {
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[(1 << 20)], b[(1 << 20)];
long long f[(1 << 20)];
struct line {
long double l, r;
long long k, b;
int index;
line(long long k, long long b, int ind) {
this->k = k;
this->b = b;
this->index = ind;
l = -1E10;
r = 1E10;
}
};
long double line_inter(line ln1, line ln2) {
long long k1, b1, k2, b2;
k1 = ln1.k;
b1 = ln1.b;
k2 = ln2.k;
b2 = ln2.b;
assert(k1 - k2);
return ((long double)(b2 - b1)) / ((long double)(k1 - k2));
}
int main() {
int i, j, n;
cin >> n;
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 0; i < n; ++i) cin >> b[i];
deque<line> d;
d.push_back(line(b[0], 0, 0));
int low, high, middle;
for (i = 1; i < n; ++i) {
int sz = (int)d.size();
low = 0;
high = sz;
while (low + 1 < high) {
middle = (low + high) / 2;
if (d[middle].l <= a[i])
low = middle;
else
high = middle;
}
j = d[low].index;
f[i] = f[j] + (long long)a[i] * b[j];
line ln = line(b[i], f[i], i);
long double x1 = 0.0, x2 = 0.0;
if (sz == 1) {
x1 = line_inter(d[sz - 1], ln);
ln.l = x1;
d[sz - 1].r = x1;
} else if (sz > 1) {
do {
x1 = line_inter(d[sz - 1], ln);
x2 = line_inter(d[sz - 2], ln);
if (x1 <= x2) {
d.pop_back();
--sz;
ln.l = x2;
d[sz - 1].r = x2;
} else {
ln.l = x1;
d[sz - 1].r = x1;
}
} while (sz > 1 && x1 <= x2);
}
d.push_back(ln);
++sz;
}
cout << f[n - 1];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ana[n + 1];
int pos[n + 1];
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
pos[i] = x;
}
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
ana[x] = i;
}
vector<int> A, B;
int r = 0;
for (int u = 0; u <= n / 2; ++u) {
for (int i = n - 1; i > 0; --i) {
if (ana[pos[i]] == i) continue;
int k = i;
for (int j = k + 1; j <= n; ++j) {
if (ana[pos[j]] == j) continue;
int x = pos[k];
int y = pos[j];
if (ana[x] >= j and ana[y] <= k) {
pos[k] = y;
pos[j] = x;
A.push_back(k);
B.push_back(j);
r += abs(k - j);
k = j;
break;
}
}
}
for (int i = 1; i < n; ++i) {
if (ana[pos[i]] == i) continue;
int k = i;
for (int j = k + 1; j <= n; ++j) {
if (ana[pos[j]] == j) continue;
int x = pos[k];
int y = pos[j];
if (ana[x] >= j and ana[y] <= k) {
pos[k] = y;
pos[j] = x;
A.push_back(k);
B.push_back(j);
r += abs(k - j);
k = j;
break;
}
}
}
}
cout << r << endl;
cout << A.size() << endl;
for (int i = 0; i < A.size(); ++i) printf("%d %d\n", A[i], B[i]);
}
| 7 |
#include "bits/stdc++.h"
using namespace std;
namespace modular {
template <typename> struct is_modular: std::false_type {};
template <int M>
struct static_mint {
static_assert(0 < M, "Module must be positive");
using mint = static_mint;
int val;
static_mint(): val() {}
static_mint(long long x): val(x % M) { if (val < 0) val += M; }
mint pow(long long n) const {
mint ans = 1, x( * this);
while (n) {
if (n & 1) ans *= x;
x *= x;
n /= 2;
}
return ans;
}
mint inv() const {
return pow(M - 2);
}
friend mint pow(const mint & m, long long n) {
return m.pow(n);
}
friend mint inv(const mint & m) {
return m.inv();
}
mint operator + () const {
mint m;
m.val = val;
return m;
}
mint operator - () const {
mint m;
m.val = M - val;
return m;
}
mint & operator += (const mint & m) {
if ((val += m.val) >= M) val -= M;
return *this;
}
mint & operator -= (const mint & m) {
if ((val -= m.val) < 0) val += M;
return *this;
}
mint & operator *= (const mint & m) {
val = (long long) val * m.val % M;
return *this;
}
mint & operator /= (const mint & m) {
val = (long long) val * m.inv().val % M;
return *this;
}
friend mint operator + (const mint & lhs,
const mint & rhs) {
return mint(lhs) += rhs;
}
friend mint operator - (const mint & lhs,
const mint & rhs) {
return mint(lhs) -= rhs;
}
friend mint operator * (const mint & lhs,
const mint & rhs) {
return mint(lhs) *= rhs;
}
friend mint operator / (const mint & lhs,
const mint & rhs) {
return mint(lhs) /= rhs;
}
friend bool operator == (const mint & lhs,
const mint & rhs) {
return lhs.val == rhs.val;
}
friend bool operator != (const mint & lhs,
const mint & rhs) {
return lhs.val != rhs.val;
}
mint & operator++() {
return *this += 1;
}
mint & operator--() {
return *this -= 1;
}
mint operator++(int) {
mint result( * this);* this += 1;
return result;
}
mint operator--(int) {
mint result( * this);* this -= 1;
return result;
}
template <typename T> explicit operator T() const {
return T(val);
}
friend std::ostream & operator << (std::ostream & os,
const mint & m) {
return os << m.val;
}
friend std::istream & operator >> (std::istream & is, mint & m) {
long long x;
is >> x;
m = x;
return is;
}
};
template <int M> struct is_modular < static_mint <M>>: std::true_type {};
template <int& _M> struct dynamic_mint {
static constexpr int& M = _M;
using mint = dynamic_mint;
int val;
dynamic_mint(): val() {}
dynamic_mint(long long x): val(x % M) {
if (val < 0) {
val += M;
}
}
mint pow(long long n) const {
mint ans = 1, x( * this);
while (n) {
if (n & 1) ans *= x;
x *= x;
n /= 2;
}
return ans;
}
mint inv() const {
return pow(M - 2);
}
friend mint pow(const mint & m, long long n) {
return m.pow(n);
}
friend mint inv(const mint & m) {
return m.inv();
}
mint operator + () const {
mint m;
m.val = val;
return m;
}
mint operator - () const {
mint m;
m.val = M - val;
return m;
}
mint & operator += (const mint & m) {
if ((val += m.val) >= M) val -= M;
return *this;
}
mint & operator -= (const mint & m) {
if ((val -= m.val) < 0) val += M;
return *this;
}
mint & operator *= (const mint & m) {
val = (long long) val * m.val % M;
return *this;
}
mint & operator /= (const mint & m) {
val = (long long) val * m.inv().val % M;
return *this;
}
friend mint operator + (const mint & lhs,
const mint & rhs) {
return mint(lhs) += rhs;
}
friend mint operator - (const mint & lhs,
const mint & rhs) {
return mint(lhs) -= rhs;
}
friend mint operator * (const mint & lhs,
const mint & rhs) {
return mint(lhs) *= rhs;
}
friend mint operator / (const mint & lhs,
const mint & rhs) {
return mint(lhs) /= rhs;
}
friend bool operator == (const mint & lhs,
const mint & rhs) {
return lhs.val == rhs.val;
}
friend bool operator != (const mint & lhs,
const mint & rhs) {
return lhs.val != rhs.val;
}
mint & operator++() {
return *this += 1;
}
mint & operator--() {
return *this -= 1;
}
mint operator++(int) {
mint result( * this);* this += 1;
return result;
}
mint operator--(int) {
mint result( * this);* this -= 1;
return result;
}
template <typename T> explicit operator T() const {
return T(val);
}
friend std::ostream & operator << (std::ostream & os,
const mint & m) {
return os << m.val;
}
friend std::istream & operator >> (std::istream & is, mint & m) {
long long x;
is >> x;
m = x;
return is;
}
};
};
using im = modular::static_mint<998244353>;
constexpr int N = 503;
int n;
int a[N];
im dp1[2][N];
im dp2[2][N];
// dp1 = ways to get to i with j to cover
int b[N];
im p2[N];
im solve_case(int k) {
for (int i = 1; i <= n; i ++) {
if (a[i] == -1)
b[i] = -1;
else {
if (a[i] < a[k] || (a[i] == a[k] && i < k))
b[i] = 1;
else
b[i] = 0;
}
}
for (int i = 0; i < 2; i ++)
for (int j = 0; j <= n; j ++) {
dp1[i][j] = 0;
dp2[i][j] = 0;
}
dp1[0][0] = 1;
int cur = 0, nxt = 1;
for (int i = 0; i + 1 < k; i ++) {
for (int j = 0; j <= n; j ++) {
// dont take
dp1[nxt][j] += dp1[cur][j];
// take
if (b[i + 1] == -1)
dp1[nxt][max(0, j + b[i + 1])] += dp1[cur][j];
else if (j + b[i + 1] <= n)
dp1[nxt][j + b[i + 1]] += dp1[cur][j];
dp1[cur][j] = 0;
}
swap(cur, nxt);
}
if (k == n) {
return p2[k - 1];
}
for (int i = 0; i < n; i ++)
dp2[cur][i + 1] = dp1[cur][i];
for (int i = k; i < n; i ++) {
for (int j = 1; j <= n; j ++) {
// only those alive matters
// skip then
dp2[nxt][j] += dp2[cur][j];
// take
if (b[i + 1] == -1)
dp2[nxt][j - 1] += dp2[cur][j];
else {
if (j + b[i + 1] <= n)
dp2[nxt][j + b[i + 1]] += dp2[cur][j];
}
dp2[cur][j] = 0;
}
swap(cur, nxt);
}
im res = 0;
for (int i = 1; i <= n; i ++)
res += dp2[cur][i];
return res;
}
void solution() {
cin >> n;
for (int i = 1; i <= n; i ++) {
string s;
cin >> s;
if (s[0] == '-') a[i] = -1;
else {
cin >> a[i];
}
}
im ans = 0;
for (int i = 1; i <= n; i ++)
if (a[i] != -1)
ans += solve_case(i) * a[i];
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); int tc = 1;
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
p2[0] = 1;
for (int i = 1; i < N; i ++) p2[i] = p2[i - 1] * 2;
// cin >> tc;
while (tc --) { solution(); cout << "\n"; }
} | 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m, tot;
map<int, int> id, ma;
vector<int> G[100005];
int sizes[100005];
long long ans = 0;
bool vis[100005];
struct edge {
int l, r;
} e[10];
int ask(int x) {
if (id[x]) return id[x];
tot++;
ma[tot] = x;
return id[x] = tot;
}
void climb(int x) {
if (!x) return;
ask(x);
climb(x / 2);
}
void add(int x, int y) {
G[x].push_back(y);
G[y].push_back(x);
}
void Size(int l, int r, int &siz) {
if (n < l) return;
if (n < r) {
siz += n - l + 1;
return;
}
siz += r - l + 1;
Size(l << 1, r << 1 | 1, siz);
}
void Solve(int x) {
if (id[x << 1]) sizes[id[x]] -= sizes[id[x << 1]], Solve(x << 1);
if (id[x << 1 | 1]) sizes[id[x]] -= sizes[id[x << 1 | 1]], Solve(x << 1 | 1);
}
void dfs(int x, int fac) {
ans = (1ll * sizes[fac] * sizes[x] % mod + ans) % mod;
int sz = G[x].size();
for (int i = 0; i < sz; i++)
if (!vis[G[x][i]]) vis[G[x][i]] = 1, dfs(G[x][i], fac), vis[G[x][i]] = 0;
}
int main() {
scanf("%d%d", &n, &m);
ask(1);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
climb(x);
climb(y);
add(ask(x), ask(y));
}
for (int i = 1; i <= tot; i++)
if (ma[i] > 1) add(i, id[ma[i] / 2]);
for (int i = 1; i <= tot; i++) Size(ma[i], ma[i], sizes[i]);
Solve(1);
for (int i = 1; i <= tot; i++) vis[i] = 1, dfs(i, i), vis[i] = 0;
printf("%lld\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 5;
const int INF = 0x3f3f3f3f;
const int dr[] = {0, 0, 1, -1};
const int dc[] = {1, -1, 0, 0};
struct node {
int r, c;
node(int rr = 0, int cc = 0) : r(rr), c(cc) {}
};
int n, m;
char s[maxn][maxn];
int r2, c2;
bool is_in(int r, int c) { return r >= 0 && r < n && c >= 0 && c < m; }
bool bfs(int r, int c) {
queue<node> q;
q.push(node(r, c));
s[r][c] = 'X';
while (!q.empty()) {
node u = q.front();
q.pop();
for (int i = 0; i < 4; ++i) {
int x = u.r + dr[i];
int y = u.c + dc[i];
if (x == r2 && y == c2 && s[x][y] == 'X') return true;
if (is_in(x, y) && s[x][y] == '.') {
s[x][y] = 'X';
q.push(node(x, y));
}
}
}
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
int r1, c1;
cin >> r1 >> c1 >> r2 >> c2;
--r1, --r2, --c1, --c2;
if (bfs(r1, c1))
puts("YES");
else
puts("NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int DIM = 5e3 + 5;
const int INF = 1e9 + 7;
int cst1[DIM], cst2[DIM];
int dp[DIM][DIM][2], cnt[DIM];
vector<int> edg[DIM];
void dfs1(int x) {
cnt[x] = 1;
for (int y : edg[x]) {
dfs1(y);
cnt[x] += cnt[y];
}
for (int i = 0; i <= cnt[x]; i++) dp[x][i][0] = dp[x][i][1] = INF;
return;
}
void dfs2(int x) {
cnt[x] = 1;
dp[x][0][0] = 0;
dp[x][1][0] = cst1[x];
dp[x][1][1] = cst2[x];
for (int y : edg[x]) {
dfs2(y);
cnt[x] += cnt[y];
for (int i = cnt[x]; i >= 1; i--) {
for (int j = max(0, i - cnt[y]); j <= min(i - 1, cnt[x] - cnt[y]); j++) {
dp[x][i][0] = min(dp[x][i][0], dp[x][j][0] + dp[y][i - j][0]);
if (j != 0)
dp[x][i][1] = min(
dp[x][i][1], dp[x][j][1] + min(dp[y][i - j][0], dp[y][i - j][1]));
}
}
}
return;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
int n, b;
cin >> n >> b;
for (int i = 1; i <= n; i++) {
cin >> cst1[i] >> cst2[i];
cst2[i] = cst1[i] - cst2[i];
if (i >= 2) {
int x;
cin >> x;
edg[x].push_back(i);
}
}
dfs1(1);
dfs2(1);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (min(dp[1][i][0], dp[1][i][1]) <= b) ans = i;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long mod = a % b;
long long ans = b - mod;
if (mod == 0)
cout << 0 << endl;
else
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int N;
int to[MAXN];
bool visited[MAXN];
vector<long long> compSizes;
void go(int v, int size) {
visited[v] = true;
if (!visited[to[v]])
go(to[v], size + 1);
else
compSizes.push_back(size);
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d", &to[i]);
}
for (int i = 1; i <= N; ++i) {
if (!visited[i]) {
go(i, 1);
}
}
sort(compSizes.begin(), compSizes.end());
if (compSizes.size() == 1) {
cout << compSizes[0] * compSizes[0] << endl;
} else {
long long ans = 0;
for (int i = 0; i < (int)compSizes.size(); ++i) {
ans += compSizes[i] * compSizes[i];
if (i == (int)compSizes.size() - 1) {
ans += 2 * compSizes[i] * compSizes[i - 1];
}
}
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int f[1002][1002][2];
int a[1002][1002][2];
int fx[1002][1002][2];
int v[1002][1002][2];
int dfs(int x, int y, int k) {
if (x == 1 && y == 1) {
if (k == 0) return a[1][1][0];
if (k == 1) return a[1][1][1];
}
if (x <= 0 || y <= 0) return 1e7;
if (v[x][y][k] != 0) return f[x][y][k];
v[x][y][k] = 1;
int ans;
ans = dfs(x - 1, y, k);
fx[x][y][k] = 0;
int ans2 = dfs(x, y - 1, k);
if (ans2 < ans) {
ans = ans2;
fx[x][y][k] = 1;
}
if (k == 0) f[x][y][k] = ans + (a[x][y][k]);
if (k == 1) f[x][y][k] = ans + (a[x][y][k]);
return f[x][y][k];
}
void out(int x, int y, int k) {
if (x <= 0 || y <= 0) return;
if (x == 1 && y == 1) return;
if (fx[x][y][k] == 0) {
out(x - 1, y, k);
putchar('D');
} else {
out(x, y - 1, k);
putchar('R');
}
}
int main() {
int n;
scanf("%d", &n);
int num = 0;
int numx, numy;
int x;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &x);
if (x == 0)
a[i][j][1] = a[i][j][0] = 1, num += 1, numx = i, numy = j;
else {
a[i][j][1] = a[i][j][0] = 0;
int p = x;
while (p % 2 == 0) {
a[i][j][0] += 1;
p /= 2;
}
p = x;
while (p % 5 == 0) {
a[i][j][1] += 1;
p /= 5;
}
}
}
}
int pt;
pt = dfs(n, n, 0);
int pt2;
pt2 = dfs(n, n, 1);
int k = 0;
if (pt2 < pt) {
pt = pt2;
k = 1;
}
int ans = pt;
if (num == 0 || ans <= 1) {
printf("%d\n", ans);
out(n, n, k);
return 0;
}
printf("%d\n", 1);
for (int i = 1; i < numx; i++) putchar('D');
for (int i = 1; i < numy; i++) putchar('R');
for (int i = numx; i < n; i++) putchar('D');
for (int i = numy; i < n; i++) putchar('R');
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<string> str;
int main() {
int n, i, j, k = 0, o;
string s, a;
cin >> n;
for (i = 1; i <= n; ++i) {
cin >> s;
a = "";
for (j = s.size(); j >= 0; --j) {
if (s[j] == 'u')
a += "oo";
else if (s[j] == 'h') {
a += 'h';
while (s[j - 1] == 'k') --j;
} else
a += s[j];
}
str.insert(a);
}
cout << str.size();
return 0;
}
| 2 |
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#include<stack>
#include<queue>
#include<map>
#include<set>
#define ll long long
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) a*b/(__gcd(a,b))
#define rep(i,s,e) for(int i=s;i<e;i++)
#define fep(i,s,e) for(int i=s;i<=e;i++)
#define mem(a,n) memset(a, n ,sizeof(a))
#define Fill(a,n,b) fill(a,a+n,b)
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
using namespace std;
//priority_queue <int,vector<int>,less<int> > Q;
const int eps = 1e-7;
const int inf= 0x3f3f3f3f;
const int N = 1e5+5;
pair<int,int> p[2*N];
void solve(){
int n;
cin >> n ;
for(int i=1;i<=n;i++) cin >> p[i].first;
for(int i=1;i<=n;i++) cin >> p[i].second;
sort(p+1,p+1+n);
p[0].first = 1;
p[0].second = 1;
int res = 0;
for(int i=1;i<=n;i++){
int a = p[i-1].first - p[i-1].second;
int b = p[i].first - p[i].second;
if(a == b){
if(a % 2 == 0){
res+=p[i].second - p[i-1].second;
}
} else{
res+=(b/2-a/2);
}
}
printf("%d\n",res);
}
int main(){
IOS;
int t;
cin >> t;
while(t--){
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long ans, cnt;
int main() {
cin >> s;
for (int i = s.size() - 1; i >= 4; i--) {
if (s[i] == 'l' && s[i - 1] == 'a' && s[i - 2] == 't' && s[i - 3] == 'e' &&
s[i - 4] == 'm')
cnt++;
else if (s[i] == 'y' && s[i - 1] == 'v' && s[i - 2] == 'a' &&
s[i - 3] == 'e' && s[i - 4] == 'h')
ans += cnt;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int px, py, qx, qy;
cin >> px >> py >> qx >> qy;
cout << max(abs(px - qx), abs(py - qy)) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using db = long double;
using ii = pair<int, int>;
const int N = 1e7 + 5, LG = 19, MOD = 1e9 + 7;
const int SQ = 225;
const long double EPS = 1e-7;
ll t[20004];
ll lz[20004];
ll dp[5005][5005];
ll sum[5005];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> x(n + 1);
for (int i = 1; i < n + 1; i++) cin >> x[i];
sort(x.begin() + 1, x.end());
vector<ii> vp(m + 1);
memset(dp, 63, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i < m + 1; i++) cin >> vp[i].first >> vp[i].second;
sort(vp.begin() + 1, vp.end());
deque<int> dq;
for (int i = 1; i < m + 1; i++) {
int pos = vp[i].first, cap = vp[i].second;
dp[i][0] = 0;
dq.clear();
sum[0] = 0;
dq.push_back(0);
for (int j = 1; j < n + 1; j++) {
int val = abs(x[j] - pos);
sum[j] = val + sum[j - 1];
while (dq.size() &&
dp[i - 1][j] < dp[i - 1][dq.back()] + sum[j] - sum[dq.back()]) {
dq.pop_back();
}
dq.push_back(j);
int lo = 0, hi = dq.size() - 1;
while (lo < hi) {
int md = lo + (hi - lo) / 2;
if (dq[md] >= j - cap)
hi = md;
else
lo = md + 1;
}
dp[i][j] = dp[i - 1][dq[lo]] + sum[j] - sum[dq[lo]];
}
}
if (dp[m][n] > 1ll * n * 2e9) {
cout << -1 << '\n';
} else
cout << dp[m][n] << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
struct tri {
long long num;
long long mini;
long long maxy;
};
bool isPrime(int num) {
bool flag = true;
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
flag = false;
break;
}
}
return flag;
}
int myXOR(int x, int y) { return (x | y) & (~x | ~y); }
int gcd(unsigned long long a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<int> primes;
void SieveOfEratosthenes(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++) {
if (prime[p] == true) {
primes.push_back(p);
}
}
}
void solve() {
int n, k;
cin >> n >> k;
k--;
int mat[n][n];
int c = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
mat[i][j] = c++;
}
}
for (int i = 0; i < n; i++) {
for (int j = k; j < n; j++) {
mat[i][j] = c++;
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
sum += mat[i][k];
}
cout << sum << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << mat[i][j] << " ";
}
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, v[6005], siz, a[6005], ans;
vector<int> ve[6005];
void dfs(int x, int par) {
bool op = false;
int ov;
int put = lower_bound(a + 1, a + siz + 1, v[x]) - a;
if (put > siz) {
siz++;
op = true;
}
ov = a[put];
a[put] = v[x];
if (siz > ans) ans = siz;
for (int i = 0; i < ve[x].size(); i++) {
if (ve[x][i] != par) dfs(ve[x][i], x);
}
if (op)
siz--;
else
a[put] = ov;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
ve[x].push_back(y);
ve[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) a[j] = 1000000000;
dfs(i, i);
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[1000500];
map<pair<int, long long>, bool> dp;
bool found = false;
void solve(int idx, long long sum) {
if (found) return;
if (sum && sum % m == 0) {
found = true;
return;
}
if (idx >= n) return;
bool &ret = dp[{idx, sum}];
if (ret) return;
ret = true;
solve(idx + 1, sum + a[idx]);
if (found) return;
solve(idx + 1, sum);
if (found) return;
}
int main() {
scanf("%lld%lld", &n, &m);
bool z = false;
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]), z |= (a[i] == 0);
solve(0, 0);
if (z || found) return puts("YES");
puts("NO");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int IINF = 1 << 28;
const double INF = 1e30;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
double y_1, y_2, y_w, x_b, y_b, r;
int main() {
cin >> y_1 >> y_2 >> y_w >> x_b >> y_b >> r;
if (y_2 - y_1 - 2 * r < -EPS) {
cout << -1 << endl;
return 0;
}
y_w -= r;
y_1 += r;
double x_w = (y_w - y_1) * x_b / (2 * y_w - y_1 - y_b);
double d = (y_2 - y_1) * x_w / sqrt(x_w * x_w + (y_w - y_1) * (y_w - y_1));
if (d - r < -EPS) {
cout << -1 << endl;
} else {
printf("%.8lf\n", x_w);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s, t;
cin >> s >> t;
int ans = n + 1;
vector<int> position, tposition;
for (int i = 0; i < m - n + 1; i++) {
string tmp = t.substr(i, n);
tposition.clear();
int c = 0;
for (int j = 0; j < n; j++) {
if (s[j] != tmp[j]) {
c++;
tposition.push_back(j);
}
}
if (ans > c) {
ans = c;
if (ans == 0) {
cout << ans << endl;
return 0;
}
position = tposition;
}
}
cout << ans << endl;
for (int i = 0; i < position.size(); i++) {
cout << position[i] + 1;
if (i < ans - 1) cout << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 4 * 100 * 1000 + 17;
int n, m;
int cl[MAXn];
vector<int> adj[MAXn];
long long seg[4 * MAXn][2];
bool mark[MAXn];
int tedad = 0;
pair<int, int> se[MAXn];
void DFS(int u) {
se[u].first = tedad;
mark[u] = 1;
tedad++;
for (long long i = 0; i < (adj[u].size()); i++) {
if (!mark[adj[u][i]]) {
DFS(adj[u][i]);
}
}
se[u].second = tedad;
}
void change(int p, int s, int e, int c, int l, int r) {
if (r <= s || l >= e) return;
if (l <= s && r >= e) {
seg[p][0] = 1LL << c;
seg[p][1] = 1;
return;
}
if (seg[p][1]) {
seg[p * 2][0] = seg[p][0];
seg[p * 2][1] = 1;
seg[p * 2 + 1][0] = seg[p][0];
seg[p * 2 + 1][1] = 1;
seg[p][1] = 0;
}
change(p * 2, s, (s + e) / 2, c, l, r);
change(p * 2 + 1, (s + e) / 2, e, c, l, r);
seg[p][0] = seg[p * 2][0] | seg[p * 2 + 1][0];
}
long long count(int p, int s, int e, int l, int r) {
if (r <= s || l >= e) return 0;
if (l <= s && r >= e) {
return seg[p][0];
}
if (seg[p][1]) {
seg[p * 2][0] = seg[p][0];
seg[p * 2][1] = 1;
seg[p * 2 + 1][0] = seg[p][0];
seg[p * 2 + 1][1] = 1;
seg[p][1] = 0;
}
return count(p * 2, s, (s + e) / 2, l, r) |
count(p * 2 + 1, (s + e) / 2, e, l, r);
}
void MAKE(int u) {
mark[u] = 1;
change(1, 0, n, cl[u], se[u].first, se[u].second);
for (long long i = 0; i < (adj[u].size()); i++) {
if (!mark[adj[u][i]]) MAKE(adj[u][i]);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (long long i = 0; i < (n); i++) {
cin >> cl[i + 1];
}
for (long long i = 0; i < (n - 1); i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
DFS(1);
memset(mark, 0, sizeof(mark));
MAKE(1);
for (long long i = 0; i < (m); i++) {
int t;
cin >> t;
if (t == 1) {
int u, c;
cin >> u >> c;
change(1, 0, n, c, se[u].first, se[u].second);
} else {
int u;
cin >> u;
long long color = count(1, 0, n, se[u].first, se[u].second);
cout << __builtin_popcount(color) + __builtin_popcount(color >> 32)
<< endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[5], b, n, sum, ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> b;
a[b]++;
sum += b;
}
if (sum == 1 || sum == 2 || sum == 5) {
cout << -1;
return 0;
}
if (a[1] + a[2] > 0) {
if (a[1] <= a[2]) {
ans += a[1];
a[2] -= a[1];
a[3] += a[1];
ans += (2 * (a[2] / 3));
a[2] %= 3;
a[3] += (2 * (a[2] / 3));
if (a[4]) {
ans += a[2];
} else if (a[4] == 0 && a[2] != 0) {
ans += 2;
}
} else {
a[1] -= a[2];
a[3] += a[2];
ans += a[2];
ans += (2 * (a[1] / 3));
a[3] += (a[1] / 3);
a[1] %= 3;
if (a[3]) {
ans += a[1];
} else if (a[3] == 0 && a[1] != 0) {
ans += 2;
}
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
int n, m, q, l = 1, a[1000010], b[1000010], vis[1000010], fa[1000010];
long long sum, s[1000010], ans[1000010];
struct node {
long long val, id;
} c[1000010], k[1000010], cha[1000010];
bool cmp(node a, node b) { return a.val < b.val; }
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
void merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
sum -= s[x] - s[x - vis[x]], sum -= s[y] - s[y - vis[y]];
vis[x] += vis[y], fa[y] = x, sum += s[x] - s[x - vis[x]];
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), c[i].val = a[i], c[i].id = 1, sum += a[i];
for (int i = 1; i <= m; i++)
scanf("%d", &b[i]), c[i + n].val = b[i], c[i + n].id = 0;
for (int i = 1; i <= q; i++) scanf("%lld", &k[i].val), k[i].id = i;
sort(c + 1, c + n + m + 1, cmp), sort(k + 1, k + q + 1, cmp);
for (int i = 1; i <= n + m; i++)
fa[i] = i, cha[i].val = c[i].val - c[i - 1].val, cha[i].id = i,
vis[i] = c[i].id, s[i] = s[i - 1] + c[i].val;
sort(cha + 1, cha + n + m + 1, cmp);
for (int i = 1; i <= q; i++) {
while (l <= n + m && cha[l].val <= k[i].val)
merge(cha[l].id, cha[l].id - 1), l++;
ans[k[i].id] = sum;
}
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double mini = -1e15;
const long double maxi = 1e15;
vector<pair<long double, long double> > intervals;
struct vec2D {
long double x;
long double y;
vec2D(long double x = 0, long double y = 0) : x(x), y(y) {}
vec2D operator-(const vec2D& v) const { return vec2D(x - v.x, y - v.y); }
vec2D operator+(const vec2D& v) const { return vec2D(x + v.x, y + v.y); }
vec2D scale(long double s) { return vec2D(this->x * s, this->y * s); }
long double length() { return sqrt(this->x * this->x + this->y * this->y); }
vec2D normal() { return vec2D(-this->y, this->x).scale(1 / length()); }
};
struct sphere2D {
vec2D center;
long double r;
sphere2D(vec2D center, long double r) {
this->center = center;
this->r = r;
}
};
vec2D normi, middle, a, b;
void process_sphere(sphere2D s) {
vec2D possible_center, pos_cent;
long double begin, end, a1, a2, act, radius_l, rad_l;
begin = mini;
end = maxi;
for (int i = 0; i < 200; i++) {
act = (begin + end) / 2;
possible_center = (normi.scale(act) + middle);
radius_l = (b - possible_center).length();
pos_cent = (normi.scale(end) + middle);
rad_l = (b - pos_cent).length();
if ((s.center - possible_center).length() - s.r >= radius_l) {
if ((s.center - pos_cent).length() - s.r >= rad_l)
end = act;
else
begin = act;
} else {
if ((s.center - pos_cent).length() - s.r < rad_l)
end = act;
else
begin = act;
}
}
a1 = act;
begin = mini;
end = maxi;
for (int i = 0; i < 200; i++) {
act = (begin + end) / 2;
possible_center = (normi.scale(act) + middle);
radius_l = (b - possible_center).length();
pos_cent = (normi.scale(end) + middle);
rad_l = (b - pos_cent).length();
if ((s.center - possible_center).length() + s.r >= radius_l) {
if ((s.center - pos_cent).length() + s.r >= rad_l)
end = act;
else
begin = act;
} else {
if ((s.center - pos_cent).length() + s.r < rad_l)
end = act;
else
begin = act;
}
}
a2 = act;
if (a1 > a2) swap(a1, a2);
intervals.push_back(make_pair(a1, a2));
}
int main() {
long double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
a = vec2D(x1, y1);
b = vec2D(x2, y2);
middle = (a + b).scale(0.5);
normi = (b - a).normal();
vector<sphere2D> v;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long double a, b, c;
cin >> a >> b >> c;
v.push_back(sphere2D(vec2D(a, b), c));
}
for (int i = 0; i < n; i++) process_sphere(v[i]);
long double minix = 1e15;
intervals.push_back(make_pair(0, 0));
sort(intervals.begin(), intervals.end());
long double q = intervals[0].first - 1e-2;
for (int i = 0; i < n + 1; i++) {
if (q <= intervals[i].first) {
if (minix > (b - (middle + normi.scale(intervals[i].first))).length()) {
minix = (b - (middle + normi.scale(intervals[i].first))).length();
}
if (minix > (b - (middle + normi.scale(q))).length()) {
minix = (b - (middle + normi.scale(q))).length();
}
}
q = max(q, intervals[i].second);
}
if (minix > (b - (middle + normi.scale(q))).length()) {
minix = (b - (middle + normi.scale(q))).length();
}
cout << fixed << setprecision(12) << minix << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void get_it_done() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const long long N = 1e5 + 5;
long long dp[N];
int32_t main() {
get_it_done();
long long t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
map<long long, long long> m;
for (long long i = 0; i < n; ++i) {
m[a[i]] = i;
}
vector<long long> ans(n + 1, 0);
ans[1] = 1;
ans[n] = 1;
long long maxima = m[1];
long long minima = m[1];
for (long long i = 1; i < n + 1; ++i) {
maxima = max(maxima, m[i]);
minima = min(minima, m[i]);
if (maxima - minima + 1 <= i) {
ans[i] = 1;
}
}
for (long long i = 0; i < n; ++i) {
cout << ans[i + 1];
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m;
pair<int, int> inp[N];
int arr[N];
int idx[N];
int x, len;
int solveright(int idx, int len, int rekt);
int solveleft(int idx, int len, int rekt) {
if (len == 0) {
return idx;
}
int go;
if (arr[1] >= arr[idx] - len) {
go = 1;
} else {
go = lower_bound(arr + 1, arr + idx + 1, arr[idx] - len) - arr;
}
if (go == idx) {
if (rekt == 2) {
return idx;
}
return solveright(idx, len, 2);
}
if (rekt == 1 && len >= 2 * (arr[idx] - arr[go])) {
len %= 2 * (arr[idx] - arr[go]);
return solveleft(idx, len, rekt);
} else {
len -= arr[idx] - arr[go];
if (len >= 0) {
return solveright(go, len, 1);
}
return idx;
}
}
int solveright(int idx, int len, int rekt) {
if (len == 0) {
return idx;
}
int go;
if (arr[n] <= arr[idx] + len) {
go = n;
} else {
go = lower_bound(arr + idx, arr + 1 + n, arr[idx] + len + 1) - arr - 1;
}
if (go == idx) {
if (rekt == 2) {
return idx;
}
return solveleft(idx, len, 2);
}
if (rekt == 1 && len >= 2 * (arr[go] - arr[idx])) {
len %= 2 * (arr[go] - arr[idx]);
return solveright(idx, len, 1);
} else {
len -= arr[go] - arr[idx];
if (len >= 0) {
return solveleft(go, len, 1);
} else {
return idx;
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &inp[i].first);
inp[i].second = i;
}
sort(inp + 1, inp + 1 + n);
for (int i = 1; i <= n; ++i) {
arr[i] = inp[i].first;
idx[inp[i].second] = i;
}
while (m--) {
scanf("%d %d", &x, &len);
x = idx[x];
printf("%d\n", inp[solveright(x, len, 0)].second);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1000005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long num = 0, k = 0, tmp;
int i = 0;
while (k < 3 && i <= n) {
i++;
tmp = 1;
while (a[i + 1] == a[i]) {
tmp++;
i++;
}
num = 3 - k;
k += tmp;
}
if (num == 1) {
cout << tmp;
} else if (num == 2) {
cout << (tmp * (tmp - 1)) / 2;
} else if (num == 3) {
cout << (tmp * (tmp - 1) * (tmp - 2)) / 6;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ii = pair<int, int>;
using vii = vector<ii>;
using l = long long;
using vl = vector<l>;
using vvl = vector<vl>;
using ll = pair<l, l>;
using vll = vector<ll>;
using vvll = vector<vll>;
using lu = unsigned long long;
using vb = vector<bool>;
using vvb = vector<vb>;
using vd = vector<double>;
using vvd = vector<vd>;
const int INF = numeric_limits<int>::max();
const double EPS = 1e-10;
const l e5 = 100000, e6 = 1000000, e7 = 10000000, e9 = 1000000000;
const bool enable_log = false;
struct VoidStream {
void operator&(std::ostream&) {}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
l n;
while (cin >> n) {
vl ts;
vl ps(n);
l sum = 0;
for (l i = 0; i < n; i++) {
l t;
cin >> t;
l new_sum = sum + 20;
auto it = lower_bound(ts.begin(), ts.end(), t - 90 + 1);
if (it == ts.begin()) {
new_sum = min(new_sum, l(50));
} else {
new_sum = min(new_sum, ps[distance(ts.begin(), it) - 1] + 50);
}
it = lower_bound(ts.begin(), ts.end(), t - 1440 + 1);
if (it == ts.begin()) {
new_sum = min(new_sum, l(120));
} else {
new_sum = min(new_sum, ps[distance(ts.begin(), it) - 1] + 120);
}
cout << (new_sum - sum) << endl;
sum = new_sum;
ts.emplace_back(t);
ps[i] = new_sum;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int _I() {
int x;
scanf("%d", &x);
return x;
}
int prime[1000001] = {0};
vector<int> pp, ff[1001];
void sv() {
int i, j;
pp.push_back(2);
for (i = 4; i <= 1000000; i += 2) prime[i] = 1;
for (i = 3; i <= 1000000; i += 2) {
if (!prime[i]) {
pp.push_back(i);
for (j = i * 3; j <= 1000000; j += i + i) prime[j] = 1;
}
}
prime[0] = prime[1] = 1;
}
map<int, int> mymap;
void solve() {
string s;
cin >> s;
int sz = s.size();
int ar[11] = {0};
for (int i = 0; i < sz; i++) {
if (s[i] == 'a') ar[0]++;
if (s[i] == 'b') ar[1]++;
if (s[i] == 'l') ar[2]++;
if (s[i] == 's') ar[3]++;
if (s[i] == 'u') ar[4]++;
if (s[i] == 'r') ar[5]++;
if (s[i] == 'B') ar[6]++;
}
ar[4] = ar[4] / 2;
ar[0] = ar[0] / 2;
int mn = INT_MAX;
for (int i = 0; i < 7; i++) {
mn = min(mn, ar[i]);
}
printf("%d\n", mn);
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
struct MI {
private:
char bb[1 << 14];
FILE* f;
char *bs, *be;
char e;
bool o, l;
public:
MI() : f(stdin), bs(0), be(0) {}
inline char get() {
if (o) {
o = 0;
return e;
}
if (bs == be) be = (bs = bb) + fread(bb, 1, sizeof(bb), f);
if (bs == be) {
l = 1;
return -1;
};
return *bs++;
}
inline void unget(char c) {
o = 1;
e = c;
}
template <class T>
inline MI& operator>(T&);
};
template <class T>
struct Q {
const static bool U = T(-1) >= T(0);
};
template <>
struct Q<char> {};
template <class T>
std::ostream& operator<(std::ostream& out, const T& t) {
return out << t;
}
using std::cout;
MI cin;
const int $n = 1000005;
const int mod = 1000000007;
inline void Add(int& x, int y) {
if ((x += y) >= mod) x -= mod;
}
inline int sub(int x, int y) { return (x -= y) < 0 ? x + mod : x; }
int n, v[$n], f[$n], g[$n];
int main() {
int lst = 0, pos = 0;
char c = cin.get();
while (c != -1 && !isspace(c)) {
++pos;
if (c == '1') {
v[n++] = pos - lst - 1;
lst = pos;
}
c = cin.get();
}
v[n] = pos - lst;
if (!n) return cout < pos < ('\n'), 0;
int pre = f[0] = v[0] + 1;
for (int i = 1; i < n; ++i) {
long long t = 0;
for (int c = 0; c <= v[i]; ++c) t += g[c];
f[i] = ((long long)pre * (v[i] + 1) + t) % mod;
std::fill(g, g + v[i] + 1, sub(0, pre));
Add(pre, f[i]);
}
long long ans = 0;
for (int i = 0; i < n; ++i) ans += f[i];
cout < (ans % mod * (v[n] + 1) % mod) < ('\n');
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150005;
const int inf = 1000 * 1000 * 1000;
const int mod = 998244353;
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
int n;
int a[N];
vector<int> g[N];
bool used[N];
int sz[N];
int nn;
void dfs1(int v, int p) {
sz[v] = 1;
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
if (to == p || used[to]) continue;
dfs1(to, v);
sz[v] += sz[to];
}
}
long long pat;
int mn, gag;
void dfs2(int v, int p) {
int val = nn - sz[v];
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
if (to == p || used[to]) continue;
dfs2(to, v);
val = max(val, sz[to]);
}
if (val < mn) {
mn = val;
gag = v;
}
}
int findcenter(int v) {
if (sz[v] == 0) {
dfs1(v, -1);
}
nn = sz[v];
mn = inf;
dfs2(v, -1);
dfs1(gag, -1);
return gag;
}
vector<pair<int, int> > P;
long long pref[N], p1[N], p2[N];
pair<long long, long long> t[4 * N];
bool mark[4 * N];
vector<int> A;
void update(int v, int s, int e, long long k, long long b) {
if (mark[v] == false) {
A.push_back(v);
mark[v] = true;
}
int m = (s + e) / 2;
bool L = (k * s + b) < (t[v].first * s + t[v].second);
bool M = (k * m + b) < (t[v].first * m + t[v].second);
if (M) {
swap(k, t[v].first);
swap(b, t[v].second);
}
if (s == e) return;
if (L != M) {
update(2 * v, s, m, k, b);
} else {
update(2 * v + 1, m + 1, e, k, b);
}
}
long long get(int v, int s, int e, int x) {
if (s == e) {
return t[v].first * x + t[v].second;
}
int m = (s + e) / 2;
if (x <= m) {
return min(t[v].first * x + t[v].second, get(2 * v, s, m, x));
}
return min(t[v].first * x + t[v].second, get(2 * v + 1, m + 1, e, x));
}
long long get(int x) { return -get(1, 1, n, x); }
void add(long long k, long long b) { update(1, 1, n, -k, -b); }
void solve(int v, int r, int p) {
if (p == -1) {
pref[v] = a[v];
p1[v] = a[v];
p2[v] = a[v];
} else {
P.push_back(make_pair(v, r));
}
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
if (to == p || used[to]) continue;
pref[to] = pref[v] + a[to];
p2[to] = p2[v] + (r + 1) * 1ll * a[to];
p1[to] = p1[v] + a[to] + pref[v];
pat = max(pat, max(p1[to], p2[to]));
solve(to, r + 1, v);
if (p == -1) {
for (int i = 0; i < (int)P.size(); i++) {
int gg = P[i].first;
int x = P[i].second;
pat = max(pat, get(x) + p1[gg]);
}
for (int i = 0; i < (int)P.size(); i++) {
int gg = P[i].first;
add(pref[gg] - a[v], p2[gg] - pref[gg]);
}
P.clear();
}
}
}
void centroid() {
queue<int> q;
q.push(1);
while (!q.empty()) {
int v = q.front();
q.pop();
v = findcenter(v);
int cnt = 2;
while (cnt--) {
solve(v, 1, -1);
reverse(g[v].begin(), g[v].end());
for (int i = 0; i < (int)A.size(); i++) {
t[A[i]] = make_pair(0, 0);
mark[A[i]] = false;
}
A.clear();
}
used[v] = true;
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
if (used[to]) continue;
if (sz[to] != 1) {
q.push(to);
}
}
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
pat = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pat = max(pat, 1ll * a[i]);
}
centroid();
cout << pat << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < (int)(n); i++) cin >> v[i];
int x = 0;
int y = 0;
int z = 0;
for (int i = 0; i < (int)(n); i++) {
if (v[i] == 3)
++x;
else if (v[i] == 4)
++y;
}
z = n / 3 - x - y;
if (z < 0) {
cout << -1 << endl;
return 0;
}
if (count((v).begin(), (v).end(), 1) != n / 3) {
cout << -1 << endl;
return 0;
}
if (count((v).begin(), (v).end(), 2) != y + z) {
cout << -1 << endl;
return 0;
}
if (count((v).begin(), (v).end(), 5) || count((v).begin(), (v).end(), 7)) {
cout << -1 << endl;
return 0;
}
if (count((v).begin(), (v).end(), 6) != x + z) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < (int)(x); i++) puts("1 3 6");
for (int i = 0; i < (int)(y); i++) puts("1 2 4");
for (int i = 0; i < (int)(z); i++) puts("1 2 6");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct xx {
int u, v;
char s[10];
xx(){};
xx(int a, int b, char* c) { u = a, v = b, strcpy(s, c); }
} x[2005];
vector<int> q;
int n, m;
int lmax[2005];
int rmax[2005], rmin[2005];
bool mark[2005];
bool sign = 1;
int dfs_t = 2;
void dfs(int l, int r) {
if (!sign) return;
if (lmax[l]) dfs(dfs_t++, lmax[l]);
q.push_back(l);
if (dfs_t > rmin[l]) {
sign = false;
return;
}
r = max(r, rmax[l]);
if (dfs_t <= r) dfs(dfs_t++, r);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) lmax[i] = rmax[i] = 0, rmin[i] = n + 1;
for (int i = 0; i < m; i++) {
int a, b;
char s[10];
scanf("%d%d%s", &a, &b, s);
if (a >= b) sign = 0;
if (s[0] == 'L')
lmax[a] = max(lmax[a], b);
else
rmax[a] = max(rmax[a], b), rmin[a] = min(rmin[a], b);
}
dfs(1, n);
if (!sign)
puts("IMPOSSIBLE");
else
for (int i = 0; i < n; i++) printf("%d ", q[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 500, mod = 998244353, blo = 20;
int K, tmp[N], tmpa[N], tmpb[N], rev[N], b[N], tw[N], w[N], limn, n, qn;
vector<int> a[N];
int qpower(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
void prework(int n) {
limn = 1;
while (limn <= n) limn <<= 1;
for (int i = 1; i < limn; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) ? (limn >> 1) : 0);
for (int i = 1; i < limn; i <<= 1) {
int omg = qpower(3, (mod - 1) / (i << 1));
w[i] = 1;
for (int j = 1; j < i; j++) w[i + j] = 1ll * w[i + j - 1] * omg % mod;
}
}
void NTT(int a[], int l) {
for (int i = 0; i < l; i++) tmp[rev[i] / (limn / l)] = a[i];
for (int i = 1; i < l; i <<= 1)
for (int j = 0; j < l; j += i << 1)
for (int k = 0; k < i; k++) {
int x = tmp[j + k], y = 1ll * w[i + k] * tmp[i + j + k] % mod;
tmp[j + k] = (x + y) % mod, tmp[i + j + k] = (x - y) % mod;
}
for (int i = 0; i < l; i++) a[i] = tmp[i];
}
void mul(const vector<int> A, const vector<int> B, vector<int>& c) {
int la = A.size(), lb = B.size(), n = la + lb - 1;
if (n <= blo) {
c.resize(n);
for (int i = 0; i < n; i++) c[i] = 0;
for (int i = 0; i < la; i++)
for (int j = 0; j < lb; j++)
c[i + j] = (c[i + j] + 1ll * A[i] * B[j]) % mod;
return;
}
int l = 1;
while (l < n) l <<= 1;
for (int i = 0; i < la; i++) tmpa[i] = A[i];
for (int i = la; i < l; i++) tmpa[i] = 0;
for (int i = 0; i < lb; i++) tmpb[i] = B[i];
for (int i = lb; i < l; i++) tmpb[i] = 0;
NTT(tmpa, l), NTT(tmpb, l);
for (int i = 0; i < l; i++) tmpa[i] = 1ll * tmpa[i] * tmpb[i] % mod;
reverse(tmpa + 1, tmpa + l);
NTT(tmpa, l);
int iv = mod - (mod - 1) / l;
if (K + 1 < n) n = K + 1;
c.resize(n);
for (int i = 0; i < n; i++) c[i] = 1ll * tmpa[i] * iv % mod;
}
void solve(int rot, int lt, int rt) {
if (lt == rt) {
a[rot].resize(2);
a[rot][0] = 1, a[rot][1] = b[lt];
return;
}
int mid = (lt + rt) >> 1;
solve(rot << 1, lt, mid), solve(rot << 1 | 1, mid + 1, rt);
mul(a[rot << 1], a[rot << 1 | 1], a[rot]);
}
int main() {
scanf("%d%d", &n, &K);
prework(n);
for (int i = 1; i <= n; i++) scanf("%d", tw + i);
scanf("%d", &qn);
for (int i = 1, opt, l, r, q, d; i <= qn; i++) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d%d", &q, &l, &d);
for (int j = 1; j <= n; j++) b[j] = q - tw[j];
b[l] = q - d;
solve(1, 1, n);
printf("%d\n", (a[1][K] + mod) % mod);
} else {
scanf("%d%d%d%d", &q, &l, &r, &d);
for (int j = 1; j <= n; j++) b[j] = q - tw[j];
for (int j = l; j <= r; j++) b[j] -= d;
solve(1, 1, n);
printf("%d\n", (a[1][K] + mod) % mod);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long double d[100100], ans = 0;
int main() {
int n, p;
scanf("%d%d", &n, &p);
for (int i = 1; i <= n; ++i) {
int l, r;
scanf("%d%d", &l, &r);
d[i] = (r / p - (l - 1) / p) / (r - l + 1.0);
}
d[n + 1] = d[1];
for (int i = 1; i <= n; ++i) {
ans += d[i] * d[i + 1] * 2000;
ans += (1 - d[i]) * d[i + 1] * 2000;
ans += d[i] * (1 - d[i + 1]) * 2000;
}
cout.precision(6);
cout << fixed << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> one;
vector<pair<long long, long long> > two;
set<pair<long long, pair<int, int> > > query;
int main(void) {
int m;
scanf("%d", &m);
long long index = 0LL;
for (int i = 0; i < m; i++) {
int idx;
scanf("%d", &idx);
if (idx == 1) {
int val;
scanf("%d", &val);
one.push_back(val);
query.insert(make_pair(-index, make_pair(1, one.size() - 1)));
index += 1LL;
} else {
long long l, c;
cin >> l >> c;
two.push_back(make_pair(l, c));
query.insert(make_pair(-index, make_pair(2, two.size() - 1)));
index += l * c;
}
}
int q;
bool first = true;
scanf("%d", &q);
while (q--) {
long long que;
cin >> que;
que--;
while (true) {
pair<long long, pair<int, int> > ques;
ques.first = -que;
ques.second = make_pair(-1, -1);
ques = *query.lower_bound(ques);
pair<int, int> sec = ques.second;
if (sec.first == 1) {
if (!first) cout << " ";
first = false;
cout << one[sec.second];
break;
} else {
pair<int, int> quez = two[sec.second];
long long resQue = que + ques.first;
resQue %= quez.first;
que = resQue;
}
}
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, i, s = 0, ans = 1e10, w, j;
cin >> n;
vector<long long> A(n);
for (i = 0; i < n; i++) {
cin >> A[i];
s += A[i];
if (i) A[i] += A[i - 1];
}
if (n == 1) {
cout << A[0];
return 0;
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
w = abs(A[j] - A[i]);
if (ans > abs(w - (s - w))) ans = abs(w - (s - w));
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
bool cmp(const string x, const string y) { return mp[x] > mp[y]; }
int main() {
int n, m;
cin >> n >> m;
vector<int> vi(n);
vector<string> vs;
for (int i = 0; i < n; i++) cin >> vi[i];
for (int i = 0; i < m; i++) {
string s;
cin >> s;
vs.push_back(s);
mp[s]++;
}
sort(vi.begin(), vi.end());
sort(vs.begin(), vs.end());
vs.erase(unique(vs.begin(), vs.end()), vs.end());
sort(vs.begin(), vs.end(), cmp);
int mul = 0;
int now = 0;
int mn = 0, mx = 0;
while (mul < m) {
mn += vi[now] * mp[vs[now]];
mul += mp[vs[now]];
now++;
}
mul = 0;
now = 0;
while (mul < m) {
mx += vi[n - 1 - now] * mp[vs[now]];
mul += mp[vs[now]];
now++;
}
cout << mn << ' ' << mx << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long t;
int main() {
cin >> t;
while (t--) {
vector<int> l, r;
long long n, ind = 1, foo = 0;
bool test = true;
string s;
cin >> n >> s;
char c[n];
for (int i = 0; i < n; i++) {
c[i] = s[i];
}
while (test) {
for (int i = 0; i < n - ind; i++) {
if (c[i] == '(' && c[i + ind] == ')') {
c[i] = '?';
c[i + ind] = '?';
}
}
ind++;
if (ind >= n) test = false;
}
for (int i = 0; i < n; i++) {
if (c[i] == '(') l.push_back(i);
if (c[i] == ')') r.push_back(i);
}
sort(l.begin(), l.end());
sort(r.begin(), r.end());
for (int i = 0; i < l.size(); i++) {
if (r[i] < l[i]) foo++;
}
cout << foo << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
int le[MAXN], ri[MAXN];
int a[MAXN];
struct num {
int val, pos;
};
num data[MAXN];
bool cmp(num a, num b) { return a.val < b.val; }
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
data[i].val = a[i];
data[i].pos = i;
le[i] = i - 1;
ri[i] = i + 1;
}
sort(data, data + n, cmp);
long long ans = 0;
int low = 0;
int hi = n - 1;
for (int i = 0; i < n - 2; i++) {
int pos = data[i].pos;
if (low == pos) {
ans += a[pos];
low = ri[pos];
} else if (hi == pos) {
ans += a[pos];
hi = le[pos];
} else {
ans += min(a[le[pos]], a[ri[pos]]);
ri[le[pos]] = ri[pos];
le[ri[pos]] = le[pos];
}
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > s;
int rep[200100];
int findset(int x) {
if (x == rep[x]) return x;
return rep[x] = findset(rep[x]);
}
void proc(int a, int b) {
pair<int, int> p = make_pair(a, b);
int A = findset(a);
if (!s.empty()) {
set<pair<int, int> >::iterator itup = s.upper_bound(p);
if (itup != s.begin()) --itup;
int low = a;
int high = b;
int last = a;
if ((*itup).first < p.first) {
if ((*itup).second < p.first) {
itup++;
} else {
low = (*itup).first;
}
}
set<pair<int, int> >::iterator itlow = itup;
while (itup != s.end() && (*itup).first <= p.second) {
for (int i = last; i <= (*itup).first; i++) {
rep[findset(i)] = A;
}
high = max((*itup).second, high);
last = (*itup).second;
itup++;
}
for (int(i) = (last); (i) < (b + 1); ++(i)) {
rep[findset(i)] = A;
}
s.erase(itlow, itup);
s.insert(make_pair(low, high));
} else {
for (int(i) = (a + 1); (i) < (b + 1); ++(i)) rep[findset(i)] = A;
s.insert(p);
}
}
int main() {
s = set<pair<int, int> >();
int n, q;
scanf("%d%d", &n, &q);
for (int(i) = (0); (i) < (n); ++(i)) rep[i + 1] = i + 1;
for (int(i) = (0); (i) < (q); ++(i)) {
int t, a, b;
scanf("%d%d%d", &t, &a, &b);
if (t == 1) {
rep[findset(a)] = findset(b);
} else if (t == 2) {
proc(a, b);
} else {
if (findset(a) == findset(b))
puts("YES");
else
puts("NO");
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef __int128_t LL;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define F first
#define S second
#define pb push_back
mt19937 rnd;
struct Point {
int x, y;
void flip() {
swap(x, y);
}
int calc() const {
return abs(x - y);
}
bool operator<(const Point& ot) const {
return std::tie(x, y) < std::tie(ot.x, ot.y);
}
};
const int N = 2e5 + 10;
Point a[N];
int pref[N];
ll solve(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
pref[i] = pref[i - 1];
if (a[i].x <= a[i].y) {
pref[i] = max(pref[i], a[i].y);
}
else if (a[1].x <= a[i].y) {
int lef = 1, rig = n;
while (lef < rig) {
int mid = (lef + rig) / 2;
if (a[mid + 1].x <= a[i].y) {
lef = mid + 1;
}
else {
rig = mid;
}
}
res = max(res, min(a[i].x, pref[lef]) - a[i].y);
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].x;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].y;
}
ll ans = 0;
for (int i = 1; i <= n; i++) {
ans += a[i].calc();
}
sort(a + 1, a + n + 1);
ll mx = 0;
mx = max(mx, solve(n));
for (int i = 1; i <= n; i++) {
a[i].flip();
}
sort(a + 1, a + n + 1);
mx = max(mx, solve(n));
cout << ans - 2 * mx << "\n";
#ifdef LOCAL
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, fldgjdflgjhrthrl, fldggfhfghjdflgjl, fldgjdflgrtyrtyjl,
ffgfldgjdflgjl, n, k, k1, k2, m, y, x;
long long dp[3][5005];
pair<long long, string> a[100500];
vector<pair<long long, string> > f, g;
string s;
long long Abs(long long x) {
if (x < 0) return -x;
return x;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> a[i].second >> a[i].first;
sort(a, a + n);
for (i = 0; i < n; i++) {
x = a[i].first;
if (x > f.size()) {
cout << -1 << endl;
return 0;
}
for (j = 0; j < x; j++) g.push_back(f[j]);
g.push_back(a[i]);
for (j = x; j < f.size(); j++) g.push_back(f[j]);
f.clear();
for (j = 0; j < g.size(); j++) f.push_back(g[j]);
g.clear();
}
for (i = 0; i < f.size(); i++)
cout << f[i].second << " " << 10000 - f[i].first << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename t>
t in(t q) {
cin >> q;
return q;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (int i = 0; i < ((int)size(v)); ++i) {
os << v[i];
if (i != ((int)size(v)) - 1) os << ",";
}
os << "]\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const map<T, S>& v) {
for (auto it : v) os << it.first << ":" << it.second << "\n";
return os;
}
template <typename T, typename S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << "(";
os << v.first << "," << v.second << ")";
return os;
}
const int OO = (int)1e9;
const double PI = acos(-1);
const int N = 100005;
long long solve(long long n, long long k) {
if (k == 0) return 1;
if (k == 1) return solve(n, k - 1);
if (k == 2) return n * (n - 1) / 2 * 1 + solve(n, k - 1);
if (k == 3) return n * (n - 1) * (n - 2) / 6 * 2 + solve(n, k - 1);
if (k == 4) return n * (n - 1) * (n - 2) * (n - 3) / 24 * 9 + solve(n, k - 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
cout << solve(n, k);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, L;
int a[55];
long long dp[2][55][55];
double res;
double sk[55];
void preCalc() {
sk[0] = 1.0 / n;
sk[n - 1] = sk[0];
for (int i = 1; i < n - 1; i++) {
sk[i] = sk[i - 1] * i / (n - i);
}
}
int main() {
scanf("%d", &n);
int r = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
r += a[i];
}
scanf("%d", &L);
if (r <= L) {
printf("%f\n", (double)n);
return 0;
}
preCalc();
res = 0;
for (int ms = 1; ms <= n; ms++) {
int v = 0;
memset(dp[v], 0, sizeof(dp[v]));
dp[v][0][0] = 1;
v ^= 1;
for (int nn = 1; nn <= n; nn++) {
memset(dp[v], 0, sizeof(dp[v]));
for (int kk = 0; kk <= nn; kk++) {
for (int LL = 0; LL <= L; LL++) {
if (dp[1 ^ v][kk][LL]) {
if (LL + a[nn] <= L && nn != ms) {
dp[v][kk + 1][LL + a[nn]] += dp[1 ^ v][kk][LL];
}
dp[v][kk][LL] += dp[1 ^ v][kk][LL];
}
if (nn == n && LL >= L - a[ms] + 1) {
res += sk[kk] * dp[v][kk][LL] * kk;
}
}
}
v ^= 1;
}
}
printf("%f\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double nthRoot(double base, int n) { return pow(base, 1.0 / n); }
int main() {
double A, B, helper;
int n;
cin >> A >> B >> n;
if (A == 0 && B == 0)
helper = 0;
else if (A == 0 && B != 0)
helper = -2;
else
helper = B / A;
bool needminus = false;
if (helper < 0 && n % 2 != 0 && n != 1) {
needminus = true;
helper = -helper;
}
double result = nthRoot(helper, n);
if (result > 0) {
result += 0.0001;
result = trunc(result * 1000);
result /= 1000;
}
int temp = trunc(result);
if (temp == result)
needminus ? cout << "-" + to_string(temp) : cout << to_string(temp);
else
cout << "No solution";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
char p;
cin >> a >> p >> b;
cin >> c >> p >> d;
a -= c;
b -= d;
if (b < 0) {
b += 60;
a--;
}
if (a < 0) {
a += 24;
}
printf("%02d:%02d\n", a, b);
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, v;
int q, i, j, k, l;
int res = 0;
scanf("%d", &n);
for (0; i < n; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &v);
if (i == j) res ^= v;
}
}
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d", &v);
if (v == 3)
printf("%d", res);
else
scanf("%d", &j), res ^= 1;
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int p[1000010];
int r[1000010];
int main() {
int n;
scanf("%d", &n);
if (n == 1) {
printf("%d %d\n", 1, 0);
return 0;
}
int ans = 1, ct = 0;
for (int i = 2; i <= n; i++) {
if (n % i == 0) {
ct++;
p[ct] = i;
ans *= i;
while (n % i == 0) {
n /= i;
r[ct]++;
}
}
}
printf("%d ", ans);
ans = 0;
int val = 0, flag = 0;
for (int i = 1; i <= ct; i++) {
val = max(val, r[i]);
if (i > 1 && r[i] != r[i - 1]) flag = 1;
}
int vv = 1;
while (true) {
if (vv >= val) break;
ans++;
vv *= 2;
}
if (vv != val) flag = 1;
if (flag) ans++;
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int is_safe(int a);
int gcd(int a, int b);
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int gre_com = arr[0];
for (int i = 1; i < n; i++) {
gre_com = gcd(gre_com, arr[i]);
}
int flag = 0;
for (int i = 0; i < n; i++) {
if (!is_safe(arr[i] / gre_com)) {
flag = 1;
break;
}
}
if (flag) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
int gcd(int a, int b) {
int r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
int is_safe(int a) {
while (a % 2 == 0) {
a = a / 2;
}
while (a % 3 == 0) {
a = a / 3;
}
if (a == 1) {
return 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod7 = 1000000007;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << ": " << a << " ";
err(++it, args...);
}
template <typename T>
long long biggest(T x) {
long long b_i = 0;
for (long long i = 0; i < x.size(); i++) {
if (x[b_i] < x[i]) {
b_i = i;
}
}
return b_i;
}
template <typename T>
long long smallest(T x) {
long long s_i = 0;
for (long long i = 0; i < x.size(); i++) {
if (x[s_i] > x[i]) {
s_i = i;
}
}
return s_i;
}
template <typename T>
string tostring(T num) {
stringstream convert;
convert << num;
return convert.str();
}
template <typename T>
long long tonumber(T stringNum) {
long long a;
stringstream convert;
convert << stringNum;
convert >> a;
return a;
}
long long A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W,
X, Y, Z;
char C1, C2, C3, C4;
string S1, S2, S3, S4;
vector<long long> V1, V2, V3, V4;
bool B1, B2;
int main() {
std::ios_base::sync_with_stdio(false);
cin.clear();
cin >> S1;
cout << (S1.length() + 1) * 26 - S1.length() << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch - '0' < 0 || ch - '0' > 9) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch - '0' >= 0 && ch - '0' <= 9) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 100000;
struct P {
long long x, y;
} p[100010 * 8], q[100], s[100010 * 8];
P operator+(P a, P b) { return (P){a.x + b.x, a.y + b.y}; }
P operator-(P a, P b) { return (P){a.x - b.x, a.y - b.y}; }
long long operator*(P a, P b) { return a.x * b.y - a.y * b.x; }
long long operator^(P a, P b) { return a.x * b.x + a.y * b.y; }
P operator*(P a, long long b) { return (P){a.x * b, a.y * b}; }
P operator/(P a, long long b) { return (P){a.x / b, a.y / b}; }
P lim[4][2] = {(P){0, 0}, (P){0, N}, (P){0, N}, (P){N, N},
(P){N, N}, (P){N, 0}, (P){N, 0}, (P){0, 0}};
int n, top, cntx, cnt;
void work(P u, P v) {
for (int i = 0; i < 4; i++) {
long long s1 = (v - u) * (lim[i][0] - u), s2 = (lim[i][1] - u) * (v - u);
if (s1 + s2 == 0) continue;
q[cntx++] = (lim[i][0] * s2 + lim[i][1] * s1) / (s1 + s2);
}
}
double dis(P a, P b) {
return sqrt((double)(a.x - b.x) * (a.x - b.x) +
(double)(a.y - b.y) * (a.y - b.y));
}
bool cmp(P a, P b) {
long long d = (a - p[1]) * (b - p[1]);
return (d > 0) || (d == 0 && dis(p[1], a) < dis(p[1], b));
}
void Convex_Hull() {
int pos = 1;
for (int i = 2; i <= cnt; i++)
if (p[i].x < p[pos].x || (p[i].x == p[pos].x && p[i].y < p[pos].y)) pos = i;
swap(p[1], p[pos]);
sort(p + 2, p + cnt + 1, cmp);
for (int i = 1; i <= cnt; i++) {
while (top > 2 && (p[i] - s[top - 1]) * (s[top] - s[top - 1]) >= 0) top--;
s[++top] = p[i];
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int x = read(), y = read(), v = read();
q[0] = (P){x, y - v};
q[1] = (P){x - v, y};
q[2] = (P){x, y + v};
q[3] = (P){x + v, y};
q[4] = (P){0, 0};
q[5] = (P){0, N};
q[6] = (P){N, 0};
q[7] = (P){N, N};
cntx = 8;
for (int i = 0; i < 4; i++) work(q[i], q[(i + 1) % 4]);
for (int i = 0; i < cntx; i++) {
if (abs(x - q[i].x) + abs(y - q[i].y) <= v && q[i].x >= 0 &&
q[i].x <= N && q[i].y >= 0 && q[i].y <= N)
p[++cnt] = q[i];
}
}
Convex_Hull();
P ans1, ans2, ans3;
double ans = 0;
for (int i = 1; i <= top; i++) {
int a = i, b = a % top + 1, c = b % top + 1;
if ((s[b] - s[a]) * (s[c] - s[a]) == 0) continue;
double r = ((double)(dis(s[a], s[b]) * dis(s[b], s[c]) * dis(s[c], s[a])) /
(double)abs((s[b] - s[a]) * (s[c] - s[a]) * 2));
if (r > ans) ans = r, ans1 = s[a], ans2 = s[b], ans3 = s[c];
}
cout << ans1.x << " " << ans1.y << endl
<< ans2.x << " " << ans2.y << endl
<< ans3.x << " " << ans3.y << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
long long res = 0;
while (t--) {
long long a[3];
long long temp = 0;
for (int i = 0; i < 3; i++) {
cin >> a[i];
temp += a[i];
}
if (temp >= 2) res++;
}
cout << res << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long mod) {
if (y < 0) return power(power(x, mod - 2, mod), -y, mod);
long long res = 1;
for (; y; y >>= 1, x = x * x % mod)
if (y & 1) res = res * x % mod;
return res;
}
const int nn = 1e5 + 10;
int x[nn], d[nn], L[nn], R[nn], q[nn], pre[nn];
int N;
int main() {
scanf("%d", &N);
for (int i = 0; i <= N + 1; ++i) scanf("%d", &x[i]);
for (int i = 1; i <= N; ++i) scanf("%d", &d[i]), d[i] *= 2;
int cnt = 1;
q[1] = 0;
R[0] = x[N + 1];
for (int i = 1; i <= N; ++i) {
int l = 1, r = cnt, mid;
while (l + 1 < r) {
mid = l + r >> 1;
if (R[q[mid]] >= x[i])
l = mid;
else
r = mid - 1;
}
if (l < cnt && R[q[l + 1]] >= x[i]) l++;
if (R[q[l]] < x[i]) continue;
R[i] = x[q[l]] + d[i];
pre[i] = x[i] - x[q[l]];
if (R[i] <= x[i]) continue;
while (cnt && R[q[cnt]] <= R[i]) cnt--;
q[++cnt] = i;
}
cnt = 1;
q[1] = N + 1;
L[N + 1] = 0;
for (int i = N; i; --i) {
int l = 1, r = cnt, mid;
while (l + 1 < r) {
mid = l + r >> 1;
if (L[q[mid]] <= x[i])
l = mid;
else
r = mid - 1;
}
if (l < cnt && L[q[l + 1]] <= x[i]) l++;
if (L[q[l]] > x[i]) continue;
L[i] = x[q[l]] - d[i];
if (L[i] >= x[i]) continue;
while (cnt && L[q[cnt]] >= L[i]) cnt--;
q[++cnt] = i;
}
int res = 2e9;
for (int i = 0; i <= N; ++i) {
if (i && R[i] >= x[N + 1]) res = 0;
if (R[i] <= x[i]) continue;
int l = 1, r = cnt, mid;
while (l + 1 < r) {
mid = l + r >> 1;
if (L[q[mid]] <= R[i])
l = mid;
else
r = mid - 1;
}
if (l < cnt && L[q[l + 1]] <= R[i]) l++;
if (x[q[l]] > x[i]) {
res = min(res, x[q[l]] - x[i]);
}
}
printf("%.10f\n", res / 2.);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, k, s, ans;
int a[200], f[152][77][5626];
int main() {
scanf("%d%d%d", &n, &k, &s);
for (long long i = 1; i <= n; i++) scanf("%d", &a[i]);
if (s >= k * n) s = k * n;
if (s >= 5625) s = 5625;
if (k > n / 2) {
for (long long i = 1; i <= n / 2; i++) swap(a[i], a[n + 1 - i]);
for (long long i = 1; i <= n; i++) a[i] = -a[i];
k = n - k;
}
memset(f, 0, sizeof(f));
for (int i = n + 1; i; i--) {
for (int j = 0; j <= k; j++) {
for (int sum = 0; sum <= s; sum++) {
f[i][j][sum] = 2e9;
}
}
}
for (long long i = 1; i <= n + 1; i++) f[i][0][0] = 0;
for (int i = n; i; i--) {
for (int j = 1; j <= min(n + 1 - i, k); j++) {
for (int sum = 0; sum <= s; sum++) {
if (i + 1 <= k + 1 - j)
f[i][j][sum] = min(f[i][j][sum], f[i + 1][j][sum] + a[i]);
else
f[i][j][sum] = min(f[i][j][sum], f[i + 1][j][sum]);
if (sum >= (i - (k + 1 - j)))
f[i][j][sum] = min(f[i][j][sum],
f[i + 1][j - 1][sum - (i - (k + 1 - j))] + a[i]);
}
}
}
ans = 2e9;
for (long long i = 0; i <= s; i++) ans = min(ans, f[1][k][i]);
if (ans <= 0) {
for (long long i = 1; i <= n; i++) ans += -a[i];
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a[n];
int i;
double mx = INT_MIN;
double sum = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (mx < a[i]) {
mx = a[i];
}
sum += a[i];
}
double ans1 = (sum - mx) * 1.0 / (n - 1);
double ans = ans1 + mx;
cout << setprecision(18) << ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> h;
long long fn(long long h) {
long long sum = 0;
while (h > 0) {
sum += h % 10;
h /= 10;
}
return sum;
}
vector<long long> ans;
int main() {
long long n;
cin >> n;
for (int i = n - 2 * sqrt(n); i < n; i++) {
if (fn(i) + i == n) {
ans.push_back(i);
}
}
cout << ans.size() << '\n';
for (long long i : ans) {
cout << i << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
int getint() {
int ret = 0;
bool ok = false, neg = false;
for (;;) {
int c = getchar();
if (c >= '0' && c <= '9')
ret = (ret << 3) + ret + ret + c - '0', ok = true;
else if (ok)
return neg ? -ret : ret;
else if (c == '-')
neg = true;
}
}
int n, m, k;
int N;
int ans[20000001], cnt[3001];
int main() {
n = getint(), m = getint(), k = getint();
N = k;
for (int i = 1; i <= k; i++) ans[i] = 1;
for (int i = 1; i <= n; i++) cnt[i] = k;
cnt[n + m + 1] = k;
for (;;) {
int i;
for (i = 1; i <= n + m; i++)
if (cnt[i] < k) break;
if (i > n + m) break;
if (!cnt[i]) i--;
ans[++N] = i;
for (int j = 0; j < n; j++) cnt[i + j]++;
}
if (cnt[n + m + 1] == k) ans[++N] = n + m;
printf("%d\n", N);
for (int i = 1; i <= N; i++) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma gcc optimize(o3)
using namespace std;
long long qpow(long long x, long long y) {
return y ? (y & 1 ? x * qpow(x, y - 1) % 1000000007
: qpow(x * x % 1000000007, y / 2))
: 1;
}
template <typename T>
inline void read(T& x) {
x = 0;
char c;
int sign = 1;
do {
c = getchar();
if (c == '-') sign = -1;
} while (!isdigit(c));
do {
x = x * 10 + c - '0';
c = getchar();
} while (isdigit(c));
x *= sign;
}
long long a, b, x, y, k;
long long gcd(long long p, long long q) {
if (q == 0) return p;
return gcd(q, p % q);
}
int main() {
read(a), read(b), read(x), read(y);
k = gcd(x, y);
x /= k, y /= k;
printf("%I64d\n", min(a / x, b / y));
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define FIO ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define mod 1000000007
#define endl "\n"
#define test ll txtc; cin>>txtc; while(txtc--)
typedef long long int ll;
typedef long double ld;
const ll mxn=2e5+1;
int main() {
FIO;
test
{
ll n; cin>>n;
vector<ll>a(n);
for(auto &it:a) cin>>it;
vector<ll>dp(mxn,0);
vector<ll>cnt(mxn,0);
for(auto it:a) cnt[it]++;
for(ll i=1;i<mxn;i++){
dp[i]+=cnt[i];
for(ll j=2*i;j<mxn;j+=i){
dp[j]=max(dp[j],dp[i]);
}
}
cout<<n-*max_element(dp.begin(),dp.end())<<endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9;
int n, m, f[MAX], ans[MAX];
vector<pair<pair<int, int>, pair<int, int> > > g[MAX];
queue<int> q;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
memset(ans, -1, sizeof ans);
cin >> n >> m;
for (int i = 0, v, u, w; i < m; i++)
cin >> v >> u >> w, v--, u--, g[v].push_back({{u, w}, {i, 0}}),
g[u].push_back({{v, w}, {i, 1}}), f[v] += w, f[u] += w;
q.push(0);
while (q.size()) {
int v = q.front();
q.pop();
if (v != n - 1)
for (auto u : g[v])
if (ans[u.second.first] == -1) {
f[u.first.first] -= 2 * u.first.second,
ans[u.second.first] = u.second.second;
if (f[u.first.first] == 0 && u.first.first != 0)
q.push(u.first.first);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, x, y, v;
cin >> a >> b >> n;
int i;
double m = 99999.0, t;
for (i = 0; i < n; i++) {
cin >> x >> y >> v;
if (x == a && y == b) {
cout << 0.00000000000;
return 0;
}
t = (double)(sqrt((x - a) * (x - a) + (y - b) * (y - b))) / v;
if (t < m) m = t;
}
printf("%.12f", m);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int err;
vector<char> best;
vector<char> curr;
int n, r;
int it;
void go(int pos, int f1, int f2, int errors) {
if (err <= errors) return;
if (pos == -1) {
err = errors;
best = curr;
} else {
if (f1 == f2) {
curr[pos] = 'T';
go(-1, 0, 0, errors + (pos + 1 < n && curr[pos + 1] == curr[pos]));
} else if (f1 > f2) {
curr[pos] = 'T';
go(pos - 1, f1 - f2, f2,
errors + (pos + 1 < n && curr[pos + 1] == curr[pos]));
} else {
curr[pos] = 'B';
go(pos - 1, f1, f2 - f1,
errors + (pos + 1 < n && curr[pos + 1] == curr[pos]));
}
}
}
int gcd(int a, int b) {
while (a && b)
if (a > b)
a %= b;
else
b %= a;
return a + b;
}
int ngcd(int a, int b) {
int res = 0;
while (a && b)
if (a > b)
res += a / b, a %= b;
else
res += b / a, b %= a;
return res;
}
int main() {
cin >> n >> r;
vector<int> nm;
for (int other = 1; other <= r; other++) {
int g = gcd(other, r);
if (g == 1) {
int t = ngcd(other, r);
if (t == n) {
nm.push_back(other);
}
}
}
if (nm.size() == 0)
puts("IMPOSSIBLE");
else {
err = n + 1;
curr.resize(n);
for (int i = (0); i < (nm.size()); i++) {
go(n - 1, r, nm[i], 0);
go(n - 1, nm[i], r, 0);
}
cout << err << endl;
for (int i = (0); i < (best.size()); i++) printf("%c", best[i]);
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll getrnd(ll l, ll r) { return uniform_int_distribution<ll>(l, r)(rng); }
template <typename T1, typename T2>
inline bool relax(T1& a, const T2& b) {
return a > b ? a = b, true : false;
}
template <typename T1, typename T2>
inline bool strain(T1& a, const T2& b) {
return a < b ? a = b, true : false;
}
const int N = 2e5 + 3;
int tree[4 * N], lazy[4 * N], a[N], ttl[4 * N], ttr[4 * N];
ll sum[4 * N];
inline void upd(int v, ll x) {
tree[v] = lazy[v] = x;
sum[v] = (ttr[v] - ttl[v] + 1) * x;
}
inline void push(int v) {
if (lazy[v]) {
upd(2 * v, lazy[v]);
upd(2 * v + 1, lazy[v]);
lazy[v] = 0;
}
}
void build(int v, int tl, int tr) {
ttl[v] = tl;
ttr[v] = tr;
if (tl == tr)
tree[v] = sum[v] = a[tl];
else {
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
tree[v] = min(tree[2 * v], tree[2 * v + 1]);
sum[v] = sum[2 * v] + sum[2 * v + 1];
}
}
void update(int v, int tl, int tr, int l, int r, int x) {
if (l > r) return;
if (tl == l && tr == r)
upd(v, x);
else {
int tm = (tl + tr) / 2;
push(v);
update(2 * v, tl, tm, l, min(r, tm), x);
update(2 * v + 1, tm + 1, tr, max(l, tm + 1), r, x);
tree[v] = min(tree[2 * v], tree[2 * v + 1]);
sum[v] = sum[2 * v] + sum[2 * v + 1];
}
}
int segsz = 0;
int seg[N];
void getSeg(int v, int tl, int tr, int l, int r) {
if (l > r) return;
if (tl == l && tr == r)
seg[segsz++] = v;
else {
int tm = (tl + tr) / 2;
push(v);
getSeg(2 * v, tl, tm, l, min(r, tm));
getSeg(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
}
int find(int v, int tl, int tr, int x) {
if (tl == tr)
return x >= tree[v] ? tl : 1e9;
else {
int tm = (tl + tr) / 2;
push(v);
if (x >= tree[2 * v])
return find(2 * v, tl, tm, x);
else
return find(2 * v + 1, tm + 1, tr, x);
}
}
inline int get(int l, int n, int x) {
segsz = 0;
getSeg(1, 0, n, l, n);
for (int i = 0; i < segsz; ++i) {
int v = seg[i];
if (x >= tree[v]) return find(v, ttl[v], ttr[v], x);
}
return 1e9;
}
int findSum(int v, int tl, int tr, ll s) {
if (tl == tr)
return s >= sum[v] ? 1e9 : tl;
else {
int tm = (tl + tr) / 2;
push(v);
if (s >= sum[2 * v])
return findSum(2 * v + 1, tm + 1, tr, s - sum[2 * v]);
else
return findSum(2 * v, tl, tm, s);
}
}
inline int getSum(int l, int n, ll s) {
segsz = 0;
getSeg(1, 0, n, l, n);
for (int i = 0; i < segsz; ++i) {
int v = seg[i];
if (s < sum[v]) return findSum(v, ttl[v], ttr[v], s);
s -= sum[v];
}
return 1e9;
}
ll segsum(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r)
return sum[v];
else {
int tm = (tl + tr) / 2;
push(v);
return segsum(2 * v, tl, tm, l, min(r, tm)) +
segsum(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
}
}
void solve() {
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> a[i];
build(1, 0, n - 1);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
int st = get(0, n - 1, y);
update(1, 0, n - 1, st, x - 1, y);
} else {
--x;
int ans = 0;
while (x < n) {
int beg = get(x, n - 1, y);
if (beg >= n) break;
int en = min(n, getSum(beg, n - 1, y)) - 1;
if (beg > en) break;
ans += en - beg + 1;
y -= segsum(1, 0, n - 1, beg, en);
x = en + 1;
}
cout << ans << '\n';
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
srand(time(0));
int t = 1;
while (t--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool flag;
struct vec {
int x, y;
inline vec(int _x = 0, int _y = 0) { x = _x, y = _y; }
inline vec operator+(vec &t) { return vec(x + t.x, y + t.y); }
inline vec operator-(vec &t) { return vec(x - t.x, y - t.y); }
inline long long lenth() { return 1LL * x * x + 1LL * y * y; }
} a[8], b[1005], bs;
inline long long crp(const vec &u, const vec &v) {
return 1LL * u.x * v.y - 1LL * v.x * u.y;
}
bool cmpByDis(const int &lhs, const int &rhs) {
return (b[lhs] - bs).lenth() < (b[rhs] - bs).lenth();
}
int stk[8], vis[1005], top;
int tot[8], o[8], id[8][1005];
vector<int> g[8][1005];
int solve(int u, int tar) {
if (u <= 0 || !id[o[u]][tar]) return k + 1;
vector<int> arr = g[o[u]][id[o[u]][tar]];
int re = 1, lastop = top;
for (int i = 0; i < arr.size() && arr[i] != tar; ++i) {
if (vis[arr[i]]) continue;
re += solve(u - re, arr[i]);
if (re > u) {
for (int i = lastop + 1; i <= top; ++i) vis[stk[i]] = false;
top = lastop;
return k + 1;
}
}
stk[++top] = tar, vis[tar] = true;
return re;
}
bool check(int tar) {
top = 0, flag = false;
memset(vis, 0, sizeof vis);
for (int i = 1; i <= k; ++i) o[i] = i;
do {
if (solve(k, tar) <= k) flag = true;
if (flag) break;
} while (next_permutation(o + 1, o + k + 1));
return flag;
}
int main() {
scanf("%d %d", &k, &n);
for (int i = 1; i <= k; ++i) scanf("%d %d", &a[i].x, &a[i].y);
for (int i = 1; i <= n; ++i) scanf("%d %d", &b[i].x, &b[i].y);
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= n; ++j) {
for (int jj = 1; jj < j; ++jj)
if (crp(a[i] - b[j], a[i] - b[jj]) == 0 &&
1LL * (a[i].x - b[j].x) * (a[i].x - b[jj].x) >= 0 &&
1LL * (a[i].y - b[j].y) * (a[i].y - b[jj].y) >= 0) {
id[i][j] = id[i][jj];
g[i][id[i][j]].push_back(j);
break;
}
if (!id[i][j]) {
id[i][j] = ++tot[i];
g[i][id[i][j]].push_back(j);
}
}
bs = a[i];
for (int j = 1; j <= tot[i]; ++j) {
sort(g[i][j].begin(), g[i][j].end(), cmpByDis);
if (g[i][j].size() > k) {
for (int ii = k; ii < g[i][j].size(); ++ii) id[i][g[i][j][ii]] = 0;
g[i][j].resize(k);
}
}
}
int ans = 0;
for (int i = 1; i <= n; ++i)
if (check(i)) ++ans;
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int *dectotr(int n) {
int *p, i1 = 1;
p = (int *)calloc(sizeof(int), 20);
p[0] = 0;
while (n != 0) {
p[i1] = n % 3;
n = n / 3;
i1++;
p[0]++;
}
return p;
}
int st(int r) {
int i, m = 1;
for (i = 1; i <= r; i++) m = m * 3;
return m;
}
int trtodec(int *p) {
int i, m = 0;
for (i = 1; i <= p[0]; i++) m = m + st(i - 1) * p[i];
return m;
}
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
int main() {
int m, i, j, a, c, *p, *pa, *pc;
scanf("%i %i", &a, &c);
pa = dectotr(a);
pc = dectotr(c);
for (i = pa[0] + 1; i <= 20; i++) pa[i] = 0;
for (i = pc[0] + 1; i <= 20; i++) pc[i] = 0;
for (i = 1; i <= 20; i++) pc[i] = (pc[i] + 3 - pa[i]) % 3;
pc[0] = pc[0] + pa[0] - min(pc[0], pa[0]);
printf("%i", trtodec(pc));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mat[2][2];
void fibo(long long n, long long m) {
if (n == 1) {
mat[0][0] = 1 % m;
mat[0][1] = 1 % m;
mat[1][0] = 1 % m;
mat[1][1] = 0;
return;
}
if (n & 1) {
fibo(n - 1, m);
long long x, y, z, w;
x = mat[0][0];
y = mat[0][1];
z = mat[1][0];
w = mat[1][1];
mat[0][0] = (x + z) % m;
mat[0][1] = (y + w) % m;
mat[1][0] = x;
mat[1][1] = y;
return;
}
fibo(n >> 1, m);
long long x, y, z, w;
x = mat[0][0];
y = mat[0][1];
z = mat[1][0];
w = mat[1][1];
mat[0][0] = ((x * x) % m + (y * z) % m) % m;
mat[0][1] = ((x * y) % m + (y * w) % m) % m;
mat[1][0] = ((z * x) % m + (w * z) % m) % m;
mat[1][1] = ((z * y) % m + (w * w) % m) % m;
return;
}
long long total(long long l, long long r, long long n) {
long long e1 = r / n;
long long e2 = l / n + 1;
if (l % n == 0) e2--;
return e1 - e2 + 1;
}
int main() {
long long m, l, r, k;
cin >> m >> l >> r >> k;
long long ans = 1, max1, max2;
if (k == 1)
ans = r;
else {
for (long long i = 1; i * i <= r; i++) {
if (total(l, r, i) >= k) ans = max(ans, i);
long long val = r / i;
if (total(l, r, val) >= k) ans = max(ans, val);
}
}
fibo(ans, m);
cout << mat[0][1] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
vector<int> a(6);
for (int i = 0; i < 6; i++) {
cin >> a[i];
}
int n;
cin >> n;
vector<pair<int, int>> c;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
for (int j = 0; j < 6; j++) {
pair<int, int> k = {t - a[j], i};
c.emplace_back(k);
}
}
sort(c.begin(), c.end());
int ans = 1e9;
int m = c.size();
multiset<int> st;
set<int> st2;
int beg = 0;
for (int i = 0; i < m;) {
while (i < m && st2.size() < n) {
st.insert(c[i].second);
st2.insert(c[i].second);
i++;
}
if (st2.size() == n) ans = min(ans, c[i - 1].first - c[beg].first);
st.erase(st.find(c[beg].second));
if (st.count(c[beg].second) == 0) st2.erase(c[beg].second);
beg++;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 1;
for (; q > 0; q--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, t = 1e5;
cin >> a;
t = min(a, t);
cin >> a;
t = min(a, t);
cin >> a;
t = min(a / 2, t);
cin >> a;
t = min(a / 7, t);
cin >> a;
t = min(a / 4, t);
cout << t;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
const long long MOD = 119 << 23 | 1;
class {
public:
set<int> S[222];
vector<int> V[222];
bool in[222][222], vis[222];
int n, ans[222];
bool dfs(int d) {
if (d == 1) {
memset(vis, 0, sizeof vis);
for (int i = 2; i <= n; ++i) vis[ans[i]] = 1;
for (int i = 1; i <= n; ++i)
if (!vis[i]) ans[d] = i;
vector<int> pos(n + 2), tail(n + 2);
for (int i = 1; i <= n; ++i) pos[ans[i]] = i;
for (int i = 1; i < n; ++i) {
int Min = 222, Max = -1;
for (int j : V[i]) Min = min(pos[j], Min), Max = max(pos[j], Max);
if (Max - Min + 1 != V[i].size()) return false;
tail[Max]++;
}
for (int i = 2; i <= n; ++i)
if (!tail[i]) return false;
return true;
}
for (int i = 1; i <= n; ++i) {
if (in[d + 1][i] && S[i].size() == 1) {
int id = *S[i].begin();
memset(in[d], 0, sizeof in[d]);
for (int j : V[id]) {
in[d][j] = 1;
S[j].erase(id);
}
for (int i = 1; i <= n; ++i)
if (in[d + 1][i]) in[d][i] = 1;
ans[d] = i;
if (dfs(d - 1)) {
return true;
}
for (int j : V[id]) {
S[j].insert(id);
}
}
}
return false;
}
void solve() {
int t;
cin >> t;
for (int tt = 1; tt <= t; ++tt) {
cin >> n;
for (int i = 1; i < n; ++i) {
int x;
cin >> x;
while (x--) {
int a;
cin >> a;
V[i].push_back(a);
S[a].insert(i);
}
}
memset(in, 0, sizeof in);
for (int i = 1; i <= n; ++i) {
if (S[i].size() == 1) {
int id = *S[i].begin();
memset(in[n], 0, sizeof in[n]);
for (int i : V[id]) in[n][i] = 1, S[i].erase(id);
ans[n] = i;
if (dfs(n - 1)) {
break;
}
for (int i : V[id]) S[i].insert(id);
}
}
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
cout << '\n';
for (int i = 1; i <= n; ++i) {
S[i].clear();
V[i].clear();
}
}
}
} NSPACE;
int main() {
;
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int min(long long int a, long long int b) { return (a < b) ? a : b; }
long long int max(long long int a, long long int b) { return (a > b) ? a : b; }
long long int fp(long long int a, long long int b) {
if (b == 0) return 1;
long long int x = fp(a, b / 2);
x = (x * x) % 1000000007;
if (b & 1) x = (x * a) % 1000000007;
return x;
}
long long int factorial(long long int n) {
long long int fact = 1;
for (long long int i = 2; i <= n; i++) fact = fact * i;
return fact;
}
long long int ncr(long long int n, long long int r) {
return factorial(n) / (factorial(r) * factorial(n - r));
}
long long int binomialCoeff(long long int n, long long int k) {
long long int dp[k + 1];
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (long long int i = 1; i <= n; i++) {
for (long long int j = min(i, k); j > 0; j--)
dp[j] = (dp[j] + dp[j - 1]) % 1000000007;
}
return dp[k] % 1000000007;
}
void c_p_c() {}
void solve() {
long long int n, m;
cin >> n >> m;
long long int a[n + 1][m + 1];
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) cin >> a[i][j];
}
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
long long int cnt = 0;
if (i - 1 >= 1) cnt++;
if (i + 1 <= n) cnt++;
if (j - 1 >= 1) cnt++;
if (j + 1 <= m) cnt++;
if (a[i][j] > cnt) {
cout << "NO"
<< "\n";
return;
}
a[i][j] = cnt;
}
}
cout << "YES"
<< "\n";
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) cout << a[i][j] << " ";
cout << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
;
cin >> t;
for (long long int o = 1; o <= t; o++) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mo;
long long mul(long long x, long long y) {
x %= mo;
y %= mo;
if (x < 0) x += mo;
if (y < 0) y += mo;
return ((x * y - (long long)((long double)x * y / mo) * mo) % mo + mo) % mo;
}
long long mul2(long long x, long long y) {
x %= mo;
y %= mo;
if (x < 0) x += mo;
if (y < 0) y += mo;
long long ans = 0;
do {
if (y & 1) {
ans += x;
if (ans >= mo) ans -= mo;
}
x <<= 1;
if (x >= mo) x -= mo;
} while (y >>= 1);
return ans;
}
long long sum(long long x) {
if (x & 1)
return mul((x + 1) >> 1, x);
else
return mul(x >> 1, x + 1);
}
long long sqsum(long long n) {
long long p = n, q = n + 1, r = 2 * n + 1;
if (p % 3 == 0)
p /= 3;
else if (q % 3 == 0)
q /= 3;
else
r /= 3;
if (p & 1)
q >>= 1;
else
p >>= 1;
return mul(mul(p, q), r);
}
long long work(long long x, long long y) {
if (x == y) return sum(x * x);
long long ans = 0;
if (x < y) {
ans += sum(x * x);
long long tmp = sqsum(y - 1) - sqsum(x - 1) + y - x;
tmp = (mul(tmp, x) + mul(y - x, sum(x - 1))) % mo;
ans = (ans + tmp) % mo;
if (ans < 0) ans += mo;
return ans;
} else {
ans += sum(y * y);
long long tmp = sqsum(x) - sqsum(y);
tmp = (mul(tmp, y) - mul(x - y, sum(y - 1))) % mo;
ans = (ans + tmp) % mo;
if (ans < 0) ans += mo;
return ans;
}
}
int main() {
int tes;
scanf("%d", &tes);
while (tes--) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
long long ans1, ans2;
mo = 10000000000ll;
ans1 = (work(x2, y2) - work(x1 - 1, y2) - work(x2, y1 - 1) +
work(x1 - 1, y1 - 1)) %
mo;
if (ans1 < 0) ans1 += mo;
mo = 11037271757ll;
ans2 = (work(x2, y2) - work(x1 - 1, y2) - work(x2, y1 - 1) +
work(x1 - 1, y1 - 1)) %
mo;
if (ans2 < 0) ans2 += mo;
if (ans2 != ans1)
printf("...%010I64d\n", ans1);
else
printf("%I64d\n", ans1);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char c[6];
int main() {
for (int i = 0; i < 6; i++) cin >> c[i];
int s1 = c[0] + c[1] + c[2], s2 = c[3] + c[4] + c[5];
if (s1 > s2) {
for (int i = 0; i < 3; i++) swap(c[i], c[i + 3]);
}
sort(c, c + 3);
sort(c + 3, c + 6);
int pt1 = 0, pt2 = 5;
for (int i = 0; i <= 3; i++) {
s1 = c[0] + c[1] + c[2], s2 = c[3] + c[4] + c[5];
int dif = s2 - s1;
if (dif == 0) {
cout << i << endl;
return 0;
}
if (9 - (c[pt1] - '0') > (c[pt2] - '0')) {
c[pt1] += min(dif, 9 - (c[pt1] - '0'));
pt1++;
} else {
c[pt2] -= min(dif, (c[pt2] - '0'));
pt2--;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long ANS;
long long d;
cin >> n;
for (d = 3; n % d == 0; d *= 3)
;
ANS = n / d + 1;
cout << ANS << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int grand[100001];
vector<vector<pair<int, int> > > v(100001);
int mex[100001];
int main() {
int n;
scanf("%d", &n);
long long i, k;
int s;
grand[0] = 0;
for (i = 1; i <= n; i++) {
for (k = 2; 2 * n >= (2 * i - k + 1) * k && k <= i; k++) {
s = (2 * i - k + 1) * k / 2;
v[s].push_back(make_pair(i, k));
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < v[i].size(); j++) {
s = 0;
for (int k = 0; k < v[i][j].second; k++) {
s ^= grand[v[i][j].first - k];
}
mex[s] = i;
}
for (s = 0; mex[s] == i; s++)
;
grand[i] = s;
}
if (grand[n] == 0)
printf("-1\n");
else {
int res = 1000000000;
for (int j = 0; j < v[n].size(); j++) {
if (v[n][j].second < res) {
s = 0;
for (int k = 0; k < v[n][j].second; k++) {
s ^= grand[v[n][j].first - k];
}
if (s == 0) res = v[n][j].second;
}
}
printf("%d\n", res);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200005];
long long s[200005], dp[200005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
s[i] = a[i] + s[i - 1];
}
for (int i = 1; i <= n; i++) {
dp[i] = dp[max(0, i - m)] + s[i];
}
for (int i = 1; i <= n; i++) {
printf("%lld ", dp[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, M = 100005, mod = 1e9 + 7;
template <class T>
inline void gmin(T &x, const T &y) {
if (x > y) x = y;
}
template <class T>
inline void gmax(T &x, const T &y) {
if (x < y) x = y;
}
inline void ch(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline void read(int &x) {
x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
int n, ans = 0x3f3f3f3f, a, b, w, h, c[N];
void dfs(int x, int w, int h, bool chose) {
if (w >= a && h >= b) {
gmin(ans, x);
return;
}
if (x == n + 1) return;
if (w < a) dfs(x + 1, min((long long)w * c[x], (long long)0x3f3f3f3f), h, 1);
if (h < b && (c[x] != c[x - 1] || !chose))
dfs(x + 1, w, min((long long)h * c[x], (long long)0x3f3f3f3f), 0);
}
void solve(int aa, int bb) {
a = aa;
b = bb;
sort(c + 1, c + n + 1);
reverse(c + 1, c + n + 1);
dfs(1, 1, 1, 0);
}
int main() {
int a, b;
scanf("%d%d%d%d%d", &a, &b, &w, &h, &n);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
solve((a + w - 1) / w, (b + h - 1) / h);
solve((a + h - 1) / h, (b + w - 1) / w);
printf("%d\n", ans < 0x3f3f3f3f ? ans - 1 : -1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, maximum, d;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
while (cin >> n >> maximum >> d) {
int ans = 0, now = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x > maximum) continue;
now += x;
if (now > d) ans++, now = 0;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100000 + 10;
int n;
int fen[maxN];
vector<long long> Q;
long long k;
long long sum[maxN];
void go(int pos) {
for (int i = pos; i < maxN; i += (i & (-i))) fen[i]++;
}
int get(int pos) {
int ret = 0;
for (int i = pos; i > 0; i -= (i & (-i))) ret += fen[i];
return ret;
}
bool valid(long long cost) {
memset(fen, 0, sizeof fen);
go(lower_bound(Q.begin(), Q.end(), 0) - Q.begin() + 1);
long long ret = 0;
for (int i = 1; i <= n; i++) {
ret += get(upper_bound(Q.begin(), Q.end(), sum[i] - cost) - Q.begin());
go(lower_bound(Q.begin(), Q.end(), sum[i]) - Q.begin() + 1);
}
return ret >= k;
}
int main() {
scanf("%d%I64d", &n, &k);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
sum[i] = sum[i - 1] + a;
Q.push_back(sum[i]);
}
Q.push_back(0);
sort(Q.begin(), Q.end());
Q.resize(unique(Q.begin(), Q.end()) - Q.begin());
long long lo = -(1ll << 47), hi = (1ll << 47), ans = 0;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (valid(mid)) {
ans = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, m, ok, n, q, i, j;
int usa[120][120];
int tem[120][120];
map<string, int> arma;
map<int, string> inv;
string aux, aux2;
char b;
memset(usa, 0, sizeof(usa));
memset(tem, 0, sizeof(tem));
scanf("%d %d %d %d ", &k, &n, &m, &q);
for (i = 0; i < n; i++) {
scanf(" ");
cin >> aux;
scanf(" ");
arma[aux] = i;
inv[i] = aux;
}
for (i = n; i < m + n; i++) {
scanf(" ");
cin >> aux;
scanf(" ");
aux[aux.length() - 1] = '\0';
arma[aux] = i;
inv[i] = aux;
b = 'a';
while (b != '\n') {
scanf(" ");
cin >> aux2;
scanf(" ");
scanf("%d%c", &j, &b);
usa[arma[aux]][arma[aux2]] = j;
}
}
for (i = 0; i < q; i++) {
scanf("%d", &j);
scanf(" ");
cin >> aux;
tem[j][arma[aux]]++;
for (int jj = n; jj < n + m; jj++) {
ok = 1;
for (int ii = 0; ii < n; ii++) {
if (usa[jj][ii] > tem[j][ii]) ok = 0;
}
if (ok) {
for (int ii = 0; ii < n; ii++) {
tem[j][ii] -= usa[jj][ii];
}
tem[j][jj]++;
}
}
}
for (i = 1; i <= k; i++) {
int tot = 0;
map<string, int> kkk;
for (j = 0; j < n + m; j++)
if (tem[i][j] != 0) {
tot++;
kkk[inv[j]] = tem[i][j];
}
printf("%d\n", tot);
for (map<string, int>::iterator iii = kkk.begin(); iii != kkk.end();
iii++) {
printf("%s %d\n", iii->first.c_str(), iii->second);
}
}
}
| 6 |
#include <bits/stdc++.h>
inline void swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
int n, m;
int a[512][512];
long long ps[512][512];
long long val[2][512][512];
inline long long getpr(int i, int j, int k) {
return ps[i + k - 1][j + k - 1] - ps[i - 1][j + k - 1] -
ps[i + k - 1][j - 1] + ps[i - 1][j - 1];
}
int main() {
int i, j, k;
int cr, pr;
long long mx = -(1LL << 62);
scanf("%d %d", &n, &m);
memset(ps, 0, sizeof(ps));
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
ps[i][j] = ps[i - 1][j] + ps[i][j - 1] - ps[i - 1][j - 1] + a[i][j];
}
}
cr = 1;
pr = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
val[cr][i][j] = a[i][j];
}
}
swap(pr, cr);
for (k = 3; k <= m && k <= n; k = k + 2) {
for (i = 1; i + k - 1 <= n; i++) {
for (j = 1; j + k - 1 <= m; j++) {
val[cr][i][j] = getpr(i, j, k) - val[pr][i + 1][j + 1] - a[i + 1][j];
if (val[cr][i][j] > mx) mx = val[cr][i][j];
}
}
swap(pr, cr);
}
printf("%I64d\n", mx);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int i, j, k, l, m, n, d, total = 0;
scanf("%d %d %d %d %d", &k, &l, &m, &n, &d);
int ara[d + 1];
for (i = 0; i <= d; i++) ara[i] = 0;
for (i = k; i <= d; i += k) ara[i] = 1;
for (i = l; i <= d; i += l) ara[i] = 1;
for (i = m; i <= d; i += m) ara[i] = 1;
for (i = n; i <= d; i += n) ara[i] = 1;
for (i = 0; i <= d; i++) total += ara[i];
printf("%d\n", total);
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <fstream>
using namespace std;
#define int long long
#define ii pair <int, int>
#define app push_back
#define all(a) a.begin(), a.end()
#define bp __builtin_popcountll
#define ll long long
#define mp make_pair
#define x first
#define y second
#define Time (double)clock()/CLOCKS_PER_SEC
#define debug(x) std::cerr << #x << ": " << x << '\n';
#define FOR(i, n) for (int i = 0; i < n; ++i)
#define FORN(i, n) for (int i = 1; i <= n; ++i)
#define pb push_back
#define trav(a, x) for (auto& a : x)
using vi = vector<int>;
template <typename T>
std::istream& operator >>(std::istream& input, std::vector<T>& data)
{
for (T& x : data)
input >> x;
return input;
}
template <typename T>
std::ostream& operator <<(std::ostream& output, const pair <T, T> & data)
{
output << "(" << data.x << "," << data.y << ")";
return output;
}
template <typename T>
std::ostream& operator <<(std::ostream& output, const std::vector<T>& data)
{
for (const T& x : data)
output << x << " ";
return output;
}
ll div_up(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll div_down(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down
ll math_mod(ll a, ll b) { return a - b * div_down(a, b); }
#define tcT template<class T
#define tcTU tcT, class U
tcT> using V = vector<T>;
tcT> void re(V<T>& x) {
trav(a, x)
cin >> a;
}
tcT> bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
} // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
ll gcd(ll a, ll b) {
while (b) {
tie(a, b) = mp(b, a % b);
}
return a;
}
const int MOD = 998244353;
const int N = 57, C = 26, LG = 30;
int ptr = 1;
int par[N], len[N], trie[N][C], last[N];
bool term[N];
int term_link[N];
const int S = 200;
int dp[LG][S][S];
int cur[S], nu[S];
int go[N][N][N][N];
bool used[N][N];
void dfs(int u, int v) {
used[u][v] = 1;
FOR (uu, N) {
FOR (vv, N) {
if (go[u][v][uu][vv] && !used[uu][vv]) {
dfs(uu, vv);
}
}
}
}
int sz = 0;
int num[N][N];
void add(int &a, int b) {
a += b;
if (a >= MOD)
a -= MOD;
}
signed main() {
#ifdef LOCAL
#else
#define endl '\n'
ios_base::sync_with_stdio(0); cin.tie(0);
#endif
int n, m;
cin >> n >> m;
V <string> a(n);
cin >> a;
trav (s, a) {
int u = 0;
trav (c, s) {
if (!trie[u][c - 'a']) {
trie[u][c - 'a'] = ptr;
len[ptr] = len[u] + 1;
par[ptr] = u;
last[ptr] = c - 'a';
ptr++;
}
u = trie[u][c - 'a'];
}
term[u] = 1;
}
FOR (u, ptr) {
FOR (v, ptr) {
FOR (c, C) {
if (trie[u][c] && trie[v][c]) {
int uu = trie[u][c];
int vv = trie[v][c];
go[u][v][uu][vv]++;
if (term[uu]) {
go[u][v][0][vv]++;
}
if (term[vv]) {
go[u][v][uu][0]++;
}
if (term[uu] && term[vv]) {
go[u][v][0][0]++;
}
}
}
}
}
dfs(0, 0);
FOR (u, ptr) {
FOR (v, ptr) {
if (used[u][v]) {
num[u][v] = sz;
sz++;
}
}
}
assert(sz < 200);
FOR (u, ptr) {
FOR (v, ptr) {
if (used[u][v]) {
FOR (uu, ptr) {
FOR (vv, ptr) {
if (used[uu][vv]) {
dp[0][num[u][v]][num[uu][vv]] = go[u][v][uu][vv];
}
}
}
}
}
}
FORN (t, LG - 1) {
FOR (u, sz) {
FOR (v, sz) {
FOR (k, sz) {
add(dp[t][u][v], dp[t - 1][u][k] * dp[t - 1][k][v] % MOD);
}
}
}
}
cur[0] = 1;
FOR (p, LG) {
if ((m >> p) & 1) {
FOR (i, sz) {
nu[i] = 0;
}
FOR (i, sz) {
FOR (j, sz) {
add(nu[j], cur[i] * dp[p][i][j] % MOD);
}
}
FOR (i, sz) {
cur[i] = nu[i];
}
}
}
cout << cur[0] << endl;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
long long int ara[1000500];
long long int n, c = 1, mx = 1;
int main() {
scanf("%d", &n);
for (long long int i = 0; i < n; i++) scanf("%d", &ara[i]);
for (long long int i = 1; i < n; i++) {
if (ara[i - 1] <= ara[i]) c++;
mx = max(mx, c);
if (ara[i - 1] > ara[i]) {
c = 1;
}
}
cout << mx << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long g(long long n, long long m) {
long long ans = 0;
for (long long x = 1; x <= n; x++) {
long long minY = 5 - (x % 5);
if (minY <= m) ans += (m - minY) / 5 + 1;
}
return ans;
}
long long gs(long long n, long long m) {
long long ans = 0;
for (long long x = 1; x <= n; x++) {
for (long long y = 1; y <= m; y++) {
if ((x + y) % 5 == 0) ans++;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
cout << g(n, m) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool v[100000];
int a[100000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
}
vector<vector<pair<int, int> > > ans;
vector<pair<int, int> > two;
vector<pair<int, pair<int, int> > > three;
memset(v, false, sizeof(v));
for (int i = 0; i < n; i++) {
if (v[i]) continue;
int j = a[i];
v[i] = true;
vector<int> cycle;
cycle.push_back(i);
while (j != i) {
v[j] = true;
cycle.push_back(j);
j = a[j];
}
for (int k = cycle.size() - 1; k >= 3; k -= 4) {
vector<pair<int, int> > step;
if (k >= 4) {
step.push_back(make_pair(cycle[k - 4], cycle[k - 3]));
step.push_back(make_pair(cycle[k - 3], cycle[k - 2]));
step.push_back(make_pair(cycle[k - 2], cycle[k - 1]));
step.push_back(make_pair(cycle[k - 1], cycle[k]));
step.push_back(make_pair(cycle[k], cycle[k - 4]));
} else {
step.push_back(make_pair(cycle[k - 3], cycle[k - 2]));
step.push_back(make_pair(cycle[k - 2], cycle[k - 1]));
step.push_back(make_pair(cycle[k - 1], cycle[k]));
step.push_back(make_pair(cycle[k], cycle[k - 3]));
}
ans.push_back(step);
}
if (cycle.size() % 4 == 2) {
two.push_back(make_pair(cycle[0], cycle[1]));
}
if (cycle.size() % 4 == 3) {
three.push_back(make_pair(cycle[0], make_pair(cycle[1], cycle[2])));
}
}
while (two.size() > 0 && three.size() > 0) {
pair<int, int> a = two.back();
pair<int, pair<int, int> > b = three.back();
two.pop_back();
three.pop_back();
vector<pair<int, int> > step;
step.push_back(make_pair(a.first, a.second));
step.push_back(make_pair(a.second, a.first));
step.push_back(make_pair(b.first, b.second.first));
step.push_back(make_pair(b.second.first, b.second.second));
step.push_back(make_pair(b.second.second, b.first));
ans.push_back(step);
}
while (two.size() > 0) {
pair<int, int> a = two.back();
two.pop_back();
vector<pair<int, int> > step;
step.push_back(make_pair(a.first, a.second));
step.push_back(make_pair(a.second, a.first));
if (two.size() > 0) {
pair<int, int> b = two.back();
two.pop_back();
step.push_back(make_pair(b.first, b.second));
step.push_back(make_pair(b.second, b.first));
}
ans.push_back(step);
}
while (three.size() > 0) {
pair<int, pair<int, int> > a = three.back();
three.pop_back();
vector<pair<int, int> > step1;
step1.push_back(make_pair(a.first, a.second.first));
step1.push_back(make_pair(a.second.first, a.second.second));
step1.push_back(make_pair(a.second.second, a.first));
if (three.size() > 0) {
pair<int, pair<int, int> > b = three.back();
three.pop_back();
step1.push_back(make_pair(b.first, b.second.first));
step1.push_back(make_pair(b.second.first, b.first));
vector<pair<int, int> > step2;
step2.push_back(make_pair(b.first, b.second.second));
step2.push_back(make_pair(b.second.second, b.first));
if (three.size() > 0) {
pair<int, pair<int, int> > c = three.back();
three.pop_back();
step2.push_back(make_pair(c.first, c.second.first));
step2.push_back(make_pair(c.second.first, c.second.second));
step2.push_back(make_pair(c.second.second, c.first));
}
ans.push_back(step1);
ans.push_back(step2);
} else {
ans.push_back(step1);
}
}
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d\n", (int)ans[i].size());
for (int j = 0; j < ans[i].size(); j++)
if (j < ans[i].size() - 1) {
printf("%d ", ans[i][j].first + 1);
} else {
printf("%d\n", ans[i][j].first + 1);
}
for (int j = 0; j < ans[i].size(); j++)
if (j < ans[i].size() - 1) {
printf("%d ", ans[i][j].second + 1);
} else {
printf("%d\n", ans[i][j].second + 1);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long M = 5e4 + 10;
const long long mod = 1e9 + 7;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int main() {
long long t, x, y, c[10];
scanf("%lld", &t);
while (t--) {
scanf("%lld%lld", &x, &y);
for (long long i = 1; i <= 6; ++i) scanf("%lld", &c[i]);
c[1] = min(c[1], c[2] + c[6]);
c[2] = min(c[2], c[1] + c[3]);
c[3] = min(c[3], c[2] + c[4]);
c[4] = min(c[4], c[3] + c[5]);
c[5] = min(c[5], c[4] + c[6]);
c[6] = min(c[6], c[5] + c[1]);
long long minn = inf;
if (x > 0 && y > 0) {
long long tmp = min(x, y) * c[1];
if (x > y)
tmp += c[6] * (x - y);
else
tmp += c[2] * (y - x);
minn = min(minn, tmp);
} else if (x > 0 && y <= 0) {
long long tmp = c[6] * x - c[5] * y;
minn = min(minn, tmp);
} else if (x <= 0 && y > 0) {
long long tmp = c[2] * y - c[3] * x;
minn = min(minn, tmp);
} else {
x = -x, y = -y;
long long tmp = min(x, y) * c[4];
if (x > y)
tmp += (x - y) * c[3];
else
tmp += (y - x) * c[5];
minn = min(minn, tmp);
}
printf("%lld\n", minn);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
for (int l = 0; l < k; l++) {
int n, ans = 0, sum = 0, a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
if (!a) {
a++;
ans++;
}
sum += a;
}
if (!sum) ans++;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
int n;
cin >> n;
int niza[n];
for (int ctr1 = 0; ctr1 < n; ctr1++) cin >> niza[ctr1];
vector<int> vek[n + 1];
for (int ctr1 = 1; ctr1 < n; ctr1++) vek[gcd(ctr1, n)].push_back(ctr1);
long long rez = 0;
int big[n];
bool ok[n * 2];
for (int ctr1 = 1; ctr1 <= n; ctr1++) {
if (vek[ctr1].size() == 0) continue;
memset(big, -1, sizeof(big));
for (int ctr2 = 0; ctr2 < n; ctr2++)
if (niza[ctr2] > big[ctr2 % ctr1]) big[ctr2 % ctr1] = niza[ctr2];
for (int ctr2 = 0; ctr2 < 2 * n; ctr2++)
ok[ctr2] = (niza[ctr2 % n] >= big[ctr2 % ctr1]);
int cons = 0;
for (int ctr2 = 0; ctr2 < 2 * n; ctr2++) {
if (ok[ctr2])
cons++;
else
cons = 0;
if (ctr2 >= n)
rez += upper_bound(vek[ctr1].begin(), vek[ctr1].end(), cons) -
vek[ctr1].begin();
}
}
cout << rez << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
string s;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (i % n == 0 && i > 3) {
for (int j = 1; j < 2; j++)
if (s[i - j] == s[i - j - 1] && s[i - j] == s[i - j - 2]) {
ans++;
break;
}
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.);
const int maxn = 100100;
map<vector<int>, long long> ma;
string s[12];
int c[12];
long long ans = 0;
int n, m;
vector<int> vc;
void rec1(int i, int n) {
if (i == n) {
ma[vc]++;
return;
}
for (int f = 0; f < m; f++) {
if (s[f][i] == '0') {
vc[f]++;
}
}
rec1(i + 1, n);
for (int f = 0; f < m; f++) {
if (s[f][i] == '0') {
vc[f]--;
}
}
for (int f = 0; f < m; f++) {
if (s[f][i] == '1') {
vc[f]++;
}
}
rec1(i + 1, n);
for (int f = 0; f < m; f++) {
if (s[f][i] == '1') {
vc[f]--;
}
}
}
void rec2(int i, int n) {
if (i == n) {
for (int f = 0; f < m; f++) {
vc[f] = c[f] - vc[f];
}
ans += ma[vc];
for (int f = 0; f < m; f++) {
vc[f] = c[f] - vc[f];
}
return;
}
for (int f = 0; f < m; f++) {
if (s[f][i] == '0') {
vc[f]++;
}
}
rec2(i + 1, n);
for (int f = 0; f < m; f++) {
if (s[f][i] == '0') {
vc[f]--;
}
}
for (int f = 0; f < m; f++) {
if (s[f][i] == '1') {
vc[f]++;
}
}
rec2(i + 1, n);
for (int f = 0; f < m; f++) {
if (s[f][i] == '1') {
vc[f]--;
}
}
}
int main() {
{
srand(time(0));
const string file = "";
if (!file.empty()) {
freopen((file + ".in").c_str(), "r", stdin);
freopen((file + ".out").c_str(), "w", stdout);
}
}
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
cin >> s[i] >> c[i];
}
for (int i = 0; i < m; i++) {
vc.push_back(0);
}
int mid = n / 2;
rec1(0, mid);
rec2(mid, n);
printf("%I64d", ans);
return (0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long fx[4] = {1, -1, 0, 0};
long long fy[4] = {0, 0, 1, -1};
int main() {
long long n;
while (cin >> n) {
long long d = n % 7;
n = n / 7;
if (d == 0)
cout << n * 2 << " " << n * 2 << "\n";
else if (d == 1)
cout << n * 2 << " " << (n + 1) * 2 - 1 << "\n";
else if (d < 6)
cout << n * 2 << " " << (n + 1) * 2 << "\n";
else
cout << n * 2 + 1 << " " << (n + 1) * 2 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void debout() {}
template <typename Head, typename... Tail>
void debout(Head H, Tail... T) {}
void stressout() {}
template <typename Head, typename... Tail>
void stressout(Head H, Tail... T) {}
const int N = 30000, M = 20;
int matrix[N][M];
int answer[N], answer_chat[N];
void solve() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &matrix[i][j]);
}
}
for (int j = 0; j < k; j++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
answer[a]--;
answer_chat[b]++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (matrix[i][j]) answer[i] += answer_chat[j];
}
}
for (int i = 0; i < n; i++) printf("%d ", answer[i]);
}
int main() {
double begin = clock();
solve();
fprintf(stderr, "%.5lf", (clock() - begin) / CLOCKS_PER_SEC);
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.