solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 1e5 + 5;
long long far;
long long d1, d2;
long long x[N], y[N];
long long dist(long long x, long long y) { return x * x + y * y; }
long long ans = 0;
long double dist(long double x1, long double y1, long double x2,
long double y2) {
return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
}
long double sqdis(long double x1, long double y1, long double x2,
long double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
const long double EPS = 1e-8;
void calc(long long x1, long long y1, long long x2, long long y2) {
long long a = x2 - x1;
long long b = y2 - y1;
long double x = 1.0 * (b * b * x1 - a * b * y1) / (a * a + b * b);
long double y = 1.0 * (a * a * y1 - a * b * x1) / (a * a + b * b);
long double d;
if (sqdis(x1, y1, x, y) + sqdis(x, y, x2, y2) - sqdis(x1, y1, x2, y2) < EPS) {
d = dist(0, 0, x, y);
} else {
d = dist(0, 0, x2, y2);
}
if (d <= d1 && far) {
far = 0;
ans++;
}
}
void solve() {
far = 1;
long long n;
cin >> n;
cin >> d1 >> d2;
d1 *= d1;
d2 *= d2;
for (long long i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
x[i] += a;
y[i] += b;
cin >> a >> b;
x[i] -= a;
y[i] -= b;
}
if (dist(x[0], y[0]) <= d1) {
far = 0;
ans++;
}
for (long long i = 0; i < n - 1; i++) {
if (dist(x[i], y[i]) > d2) {
far = 1;
}
calc(x[i], y[i], x[i + 1], y[i + 1]);
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 110;
int N, M, K, A[NMAX][NMAX], Ans = 11;
int main() {
scanf("%i %i %i", &N, &M, &K);
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j) scanf("%i", &A[i][j]);
if (N <= K) {
for (int Conf = 0; Conf < (1 << N); ++Conf) {
int Total = 0;
for (int j = 0; j < M && Total <= K; ++j) {
int Now = 0;
for (int i = 0; i < N; ++i) {
int Bit = (Conf & (1 << i)) > 0;
Now += A[i][j] != Bit;
}
Total += min(Now, N - Now);
}
if (Total <= K) Ans = min(Ans, Total);
}
} else {
for (int i = 0; i < N; ++i) {
int Total = 0;
for (int j = 0; j < N && Total <= K; ++j)
if (i != j) {
int Now = 0;
for (int k = 0; k < M; ++k) Now += A[j][k] != A[i][k];
Total += min(Now, M - Now);
}
if (Total <= K) Ans = min(Ans, Total);
}
}
if (Ans == 11)
printf("-1");
else
printf("%i", Ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
int mark[maxn], n, m;
vector<int> v[maxn], v_[maxn], q;
int opp(int x) { return x + (x > n ? -n : n); }
void add_edge(int x, int y) {
v[opp(x)].push_back(y);
v[opp(y)].push_back(x);
v_[x].push_back(opp(y));
v_[y].push_back(opp(x));
}
void dfs(int a) {
mark[a] = 1;
for (int i = 0; i < v[a].size(); i++)
if (!mark[v[a][i]]) dfs(v[a][i]);
q.push_back(a);
}
void dfs2(int a, int c) {
mark[a] = c;
for (int i = 0; i < v_[a].size(); i++)
if (!mark[v_[a][i]]) dfs2(v_[a][i], c);
}
int main() {
cin >> n >> m;
int x, y, c;
for (int i = 0; i < m; i++) {
cin >> x >> y >> c;
if (c)
add_edge(x + n, y), add_edge(x, y + n);
else
add_edge(x, y), add_edge(x + n, y + n);
}
for (int i = 1; i <= 2 * n; i++)
if (!mark[i]) dfs(i);
memset(mark, 0, sizeof mark);
c = 1;
vector<int> ans;
for (int i = q.size() - 1; i >= 0; i--)
if (!mark[q[i]]) dfs2(q[i], c++);
for (int i = 1; i <= n; i++)
if (mark[i] == mark[i + n]) {
cout << "Impossible";
return 0;
}
for (int i = 1; i <= n; i++)
if (mark[i] > mark[i + n]) ans.push_back(i);
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
void solve() {
long long n, i;
scanf("%lld", &n);
long long o = 0, e = 0;
long long x;
for (i = 0; i < n; i++) {
scanf("%lld", &x);
if (x % 2)
o++;
else
e++;
}
if (o < e) {
printf("%lld", o);
return;
}
long long ans = e;
o -= e;
ans += o / 3;
printf("%lld", ans);
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
int C(int n, int k) {
int ans = 1;
for (int i = n; i >= n - k + 1; --i) ans *= i;
for (int i = 1; i <= k; ++i) ans /= i;
return ans;
}
void solv() {
int n;
double s;
cin >> n >> s;
for (int q = 0; q <= n; ++q) {
double p[4];
for (int i = 0; i < 4; ++i) {
p[i] = (C(q, i) * C(n - q, 3 - i)) / (double)C(n, 3);
}
double ans = p[3] + p[2] + p[1] / 2;
if (ans >= s) {
cout << q << "\n";
return;
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int tt = 1;
while (tt--) solv();
return 0;
}
| 6 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int N=102;
int a[N],b[N];
int dp[N][N*N][N]; // step, volume, k, max water
int n;
int watersum,volumesum;
int main(){
cin.tie(0);cin.sync_with_stdio(0);
cin>>n;
for(int i=0;i<n;++i)cin>>a[i]>>b[i];
for(int i=0;i<n;++i)watersum+=b[i];
for(int i=0;i<n;++i)volumesum+=a[i];
memset(dp,-1,sizeof(dp));
dp[0][0][0]=0;
for(int i=0;i<n;++i)
for(int j=0;j<=volumesum;++j)
for(int k=0;k<=n;++k)
if(~dp[i][j][k]){
dp[i+1][j][k]=max(dp[i+1][j][k],dp[i][j][k]);
dp[i+1][j+a[i]][k+1]=max(dp[i+1][j+a[i]][k+1],dp[i][j][k]+b[i]);
}
vector<ld>res(n+1);
for(int k=1;k<=n;++k)
for(int j=0;j<=volumesum;++j)
if(~dp[n][j][k])
res[k]=max(res[k],min(ld(j),dp[n][j][k]+ld(watersum-dp[n][j][k])/2));
for(int k=1;k<=n;++k)cout<<fixed<<setprecision(10)<<res[k]<<" ";cout<<endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const long long MOD = 1e9 + 7;
const long double PI = 3.1415926535897932384626433832795028841;
long long powmod(long long a, long long b) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
template <class T>
struct segtree_t {
T *t;
T *lazy;
int sz;
T (*addition_fun)(T, T);
T invalid_value;
segtree_t() {}
segtree_t(int n, T *arr, T (*add_fun)(T, T), T invalid_val) {
t = new T[4 * n];
lazy = new T[4 * n];
sz = n;
addition_fun = add_fun;
build(1, 0, n - 1, arr);
invalid_value = invalid_val;
}
void build(int i, int l, int r, T *arr) {
if (l > r) return;
lazy[i] = 0;
if (l == r) {
t[i] = arr[l];
} else {
build(i * 2, l, (l + r) / 2, arr);
build(i * 2 + 1, (l + r) / 2 + 1, r, arr);
t[i] = addition_fun(t[i * 2], t[i * 2 + 1]);
}
}
void inc_range(int l, int r, T value) {
if (l > r) return;
inc_range_rec(1, 0, sz - 1, l, r, value);
}
void inc_range_rec(int i, int l, int r, int tl, int tr, T value) {
if (lazy[i] != 0) {
t[i] += lazy[i];
if (l != r) {
lazy[i * 2] += lazy[i];
lazy[i * 2 + 1] += lazy[i];
}
lazy[i] = 0;
}
if (r < tl or l > tr) return;
if (l > r) return;
if (l >= tl and r <= tr) {
if (l != r) {
lazy[i * 2] += value;
lazy[i * 2 + 1] += value;
}
t[i] += value;
} else {
inc_range_rec(i * 2, l, (l + r) / 2, tl, tr, value);
inc_range_rec(i * 2 + 1, (l + r) / 2 + 1, r, tl, tr, value);
t[i] = addition_fun(t[i * 2], t[i * 2 + 1]);
}
}
T query_rec(int i, int l, int r, int tl, int tr) {
if (r < tl or l > tr) return invalid_value;
if (l > r) return invalid_value;
if (lazy[i] != 0) {
t[i] += lazy[i];
if (l != r) {
lazy[i * 2] += lazy[i];
lazy[i * 2 + 1] += lazy[i];
}
lazy[i] = 0;
}
if (l >= tl and r <= tr) {
return t[i];
} else {
T m1 = query_rec(i * 2, l, (l + r) / 2, tl, tr);
T m2 = query_rec(i * 2 + 1, (l + r) / 2 + 1, r, tl, tr);
if (m1 == invalid_value && m2 == invalid_value) return invalid_value;
if (m1 == invalid_value) return m2;
if (m2 == invalid_value) return m1;
return addition_fun(m1, m2);
}
}
T query(int l, int r) { return query_rec(1, 0, sz - 1, l, r); }
~segtree_t() {
delete[] t;
delete[] lazy;
}
};
const int maxn = 35 * 1e3 + 5;
const int maxk = 60;
int dp[maxk][maxn];
int a[maxn];
int last[maxn];
int aux[maxn];
int add_fun(int a, int b) { return max(a, b); }
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
set<int> occ;
for (int i = 1; i <= n; i++) {
occ.insert(a[i]);
dp[1][i] = occ.size();
}
for (int b = 2; b <= k; b++) {
fill(last, last + n + 5, b - 1);
for (int i = 0; i <= n; i++) {
if (i < b) {
aux[i] = -1e9;
} else {
aux[i] = dp[b - 1][i - 1];
}
}
segtree_t<int> *tree = new segtree_t<int>(n + 1, aux, add_fun, -1e9);
for (int i = b; i <= n; i++) {
tree->inc_range(last[a[i]] + 1, i, 1);
last[a[i]] = i;
dp[b][i] = tree->query(b, i);
}
delete tree;
}
cout << dp[k][n] << '\n';
}
| 7 |
#include <bits/stdc++.h>
char s[105];
int dp[105][2550];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < 26; i++) {
dp[0][i] = 1;
}
for (int i = 1; i < 105; i++) {
for (int j = 0; j < 2500; j++) {
for (int k = 0; k < 26; k++)
dp[i][j + k] = (dp[i][j + k] + dp[i - 1][j]) % 1000000007;
}
}
while (n--) {
int tot = 0;
scanf("%s", s);
int slen = strlen(s);
for (int i = 0; i < slen; i++) {
tot += s[i] - 'a';
}
printf("%d\n", (dp[slen - 1][tot] + 1000000007 - 1) % 1000000007);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, p[maxn], old[maxn], rt, vis[maxn];
void gen_root() {
for (int i = 0; i < n; i++) {
if (p[i] == i) {
rt = i;
return;
}
}
int cur = 0;
while (!vis[cur]) {
vis[cur] = true;
cur = p[cur];
}
p[cur] = cur;
rt = cur;
}
void connect() {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
if (p[i] == i) {
p[i] = rt;
vis[i] = true;
}
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
int cur = i;
while (vis[cur] == 0) {
vis[cur] = 100 + i;
cur = p[cur];
}
if (vis[cur] == 100 + i) {
p[cur] = rt;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
--p[i];
}
memcpy(old, p, sizeof(old));
gen_root();
connect();
int res = 0;
for (int i = 0; i < n; i++) {
if (p[i] != old[i]) {
++res;
}
}
cout << res << '\n';
for (int i = 0; i < n; i++) {
cout << p[i] + 1;
if (i + 1 < n) {
cout << ' ';
}
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, k;
while (cin >> s >> k) {
vector<long long> sol;
if (k >= 32) {
for (int i = 0; i <= 32; ++i) {
if (s & (1LL << i)) {
sol.push_back(1LL << i);
}
}
} else {
vector<long long> F(k, 0);
F[k - 1] = 1;
while (F.back() < s) {
long long f = 0;
for (int i = 1; i <= k; ++i) {
f += F[(int)F.size() - i];
}
F.push_back(f);
}
for (int i = (int)F.size() - 1; i >= 0; --i) {
if (F[i] == 0) break;
if (s >= F[i]) {
s -= F[i];
sol.push_back(F[i]);
}
}
}
if (sol.size() == 1) {
sol.push_back(0);
}
cout << sol.size() << endl;
for (int i = 0; i < (int)sol.size(); ++i) {
cout << sol[i];
if (i + 1 == (int)sol.size()) {
cout << endl;
} else {
cout << ' ';
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, cnt;
string s;
int main() {
cin >> n >> x >> y;
cin >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == '0' && s[i + 1] != '0') ++cnt;
}
if (cnt == 0)
cout << 0;
else
cout << min(y * cnt, x * (cnt - 1) + y);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
map<int, int> mp;
int main() {
int root = 1, t, n;
scanf("%d%d", &n, &t);
for (int i = 1; i < n; i++) {
mp.insert(make_pair(t, i));
scanf("%d", &t);
map<int, int>::iterator il = mp.lower_bound(t), ir = mp.upper_bound(t);
if (il == mp.begin()) {
printf("%d ", ir->first);
} else if (ir == mp.end()) {
printf("%d ", (--il)->first);
} else {
if ((ir->second) > ((--il)->second)) {
printf("%d ", ir->first);
} else {
printf("%d ", (il)->first);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e7;
vector<int> minVal(mxN + 2, 1e7 + 1);
set<int> get_primes(int num) {
set<int> result;
while (num > 1) {
result.insert(minVal[num]);
num /= minVal[num];
}
return result;
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<bool> is_primes(mxN + 2, 1);
for (int i = 2; i <= mxN / 2; ++i) {
if (!is_primes[i]) continue;
minVal[i] = i;
for (int j = 2; i * j <= mxN; ++j) {
minVal[i * j] = min(minVal[i * j], i);
is_primes[i * j] = 0;
}
}
vector<pair<int, int>> result;
for (auto x : a) {
set<int> l = get_primes(x);
if (l.size() < 2) {
result.push_back(make_pair(-1, -1));
continue;
}
int f = *l.begin(), s = 1;
int cnt = 0;
for (auto y : l) {
if (cnt > 0) {
s *= y;
}
++cnt;
}
result.push_back(make_pair(f, s));
}
for (auto x : result) {
cout << x.first << " ";
}
cout << endl;
for (auto x : result) {
cout << x.second << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int infint = (long long)1e9 + 7;
const long long inf = (long long)1e18;
const int MAXN = (int)1e5 + 3;
struct node {
long long inside, sum, size;
};
node add(node l, node r) {
return {l.inside + r.inside - l.sum * r.size + r.sum * l.size, l.sum + r.sum,
l.size + r.size};
}
node tree[6 * MAXN];
void add(int pos, int real, int s, int e, int p, int v) {
if (s == e) {
if (v == -1)
tree[p] = {0, 0, 0};
else
tree[p] = {0, real, 1};
return;
}
int m = (s + e) / 2;
if (pos <= m)
add(pos, real, s, m, 2 * p, v);
else
add(pos, real, m + 1, e, 2 * p + 1, v);
tree[p] = ::add(tree[2 * p], tree[2 * p + 1]);
}
node query(int s, int e, int ps, int pe, int p) {
if (e < ps || pe < s) return {0, 0, 0};
if (s <= ps && pe <= e) return tree[p];
int pm = (ps + pe) / 2;
return ::add(query(s, e, ps, pm, 2 * p), query(s, e, pm + 1, pe, 2 * p + 1));
}
int n, q, a[MAXN], b[MAXN];
int t[MAXN], l[MAXN], r[MAXN];
vector<int> v;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
v.push_back(a[i]);
b[i] = a[i];
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> t[i] >> l[i] >> r[i];
if (t[i] == 1) {
b[l[i]] += r[i];
v.push_back(b[l[i]]);
}
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
int sz = v.size();
for (int i = 1; i <= n; i++) {
int L = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
add(L, a[i], 0, sz - 1, 1, 1);
}
for (int i = 0; i < q; i++) {
if (t[i] == 1) {
int L = lower_bound(v.begin(), v.end(), a[l[i]]) - v.begin();
add(L, a[l[i]], 0, sz - 1, 1, -1);
a[l[i]] += r[i];
L = lower_bound(v.begin(), v.end(), a[l[i]]) - v.begin();
add(L, a[l[i]], 0, sz - 1, 1, 1);
} else {
int L = lower_bound(v.begin(), v.end(), l[i]) - v.begin();
int R = upper_bound(v.begin(), v.end(), r[i]) - v.begin() - 1;
cout << query(L, R, 0, sz - 1, 1).inside << "\n";
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 74, OO = 0x3f3f3f3f;
pair<int, int> a[N];
class DSegments {
public:
void solve(istream& cin, ostream& cout) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
if (a[i].second > a[i].first) swap(a[i].first, a[i].second);
}
sort(a, a + n);
vector<int> ans;
int lst = OO;
for (int i = 0; i < n; i++) {
if (i == 0) {
ans.push_back(a[i].first);
lst = a[i].first;
} else {
if (lst >= a[i].second) {
continue;
} else {
ans.push_back(a[i].first);
lst = a[i].first;
}
}
}
cout << ans.size() << '\n';
for (int i : ans) {
cout << i << ' ';
}
}
};
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
DSegments solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int k, out;
vector<int> vec;
cin >> s >> k;
for (int i = 0; i < 26; i++) cin >> out, vec.push_back(out);
out = 0;
int i;
for (i = 0; i < s.size(); i++) out += vec[s[i] - 'a'] * (i + 1);
int l, maximum = *max_element(vec.begin(), vec.end());
for (i++, l = 0; l < k; l++, i++) out += maximum * i;
cout << out << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 4;
const int M = 998244353;
char s[N];
int c[N];
int dp[101];
int n, q;
struct segtree {
struct item {
int a[2][2];
};
item s[N << 2];
item NEUTRAL_ELEMENT;
item single(int p, int q) {
item a;
a.a[0][0] = q, a.a[0][1] = 1;
a.a[1][0] = p, a.a[1][1] = 0;
return a;
}
int size;
item merge(item a, item b) {
item c;
c.a[0][0] = c.a[0][1] = c.a[1][0] = c.a[1][1] = 0;
for (int k = 0; k < 2; k++) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
c.a[i][j] = (c.a[i][j] + 1ll * a.a[i][k] * b.a[k][j]) % M;
}
}
}
return c;
}
void init(int n) {
item I;
I.a[0][0] = 1, I.a[0][1] = 0;
I.a[1][0] = 0, I.a[1][1] = 1;
NEUTRAL_ELEMENT = I;
size = 1;
while (size < n) size *= 2;
size = n;
}
void build(int o, int lo, int ro) {
if (ro - lo == 1) {
s[o] = NEUTRAL_ELEMENT;
return;
}
int mo = (lo + ro) / 2;
build(2 * o + 1, lo, mo);
build(2 * o + 2, mo, ro);
s[o] = merge(s[2 * o + 1], s[2 * o + 2]);
}
void build(int n) {
init(n);
build(0, 0, n);
}
void set(int i, int p, int q, int o, int lo, int ro) {
if (ro - lo == 1) {
s[o] = single(p, q);
return;
}
int mo = (lo + ro) / 2;
if (i < mo)
set(i, p, q, 2 * o + 1, lo, mo);
else
set(i, p, q, 2 * o + 2, mo, ro);
s[o] = merge(s[2 * o + 1], s[2 * o + 2]);
}
item calc(int l, int r, int o, int lo, int ro) {
if (ro <= l || lo >= r) return NEUTRAL_ELEMENT;
if (l <= lo && ro <= r) return s[o];
int mo = (lo + ro) / 2;
item s1 = calc(l, r, 2 * o + 1, lo, mo);
item s2 = calc(l, r, 2 * o + 2, mo, ro);
return merge(s1, s2);
}
void set(int i, int p, int q) { set(i, p, q, 0, 0, size); }
item calc(int l, int r) { return calc(l, r, 0, 0, size); }
};
segtree st;
int main() {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) dp[i + j]++;
}
scanf("%d%d", &n, &q);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
c[i] = s[i] - '0';
}
st.build(n);
for (int i = 1; i <= n; i++) {
int q = dp[c[i]];
int p = c[i - 1] == 1 ? dp[10 + c[i]] : 0;
st.set(i - 1, p, q);
}
while (q--) {
int x, d;
scanf("%d%d", &x, &d);
c[x] = d;
int q = dp[c[x]];
int p = c[x - 1] == 1 ? dp[10 + c[x]] : 0;
st.set(x - 1, p, q);
if (x != n) {
x++;
int q = dp[c[x]];
int p = c[x - 1] == 1 ? dp[10 + c[x]] : 0;
st.set(x - 1, p, q);
}
printf("%d\n", st.s[0].a[0][0]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char s[6000];
int a[1000];
long long calc(int l, int r) {
if (l > r) return 0;
long long res = 0;
long long prev = s[l] - '0';
l++;
while (l < r) {
if (s[l] == '+') {
res += prev;
prev = 1;
}
l++;
prev *= s[l] - '0';
l++;
}
return res + prev;
}
int main() {
long long res = 0;
gets(s);
int l = 0;
while (s[l] != '\0') l++;
int k = 1;
a[0] = -1;
for (int i = 0; i < l; i++)
if (s[i] == '*') a[k++] = i;
a[k++] = l;
for (int i = 0; i < k; i++)
for (int j = i + 1; j < k; j++) {
long long t = 1;
int pos1 = a[i] - 1;
if (a[i] > 0) {
t = s[pos1] - '0';
while (pos1 > 0 && s[pos1 - 1] == '*') {
pos1 -= 2;
t *= s[pos1] - '0';
}
}
long long q = 1;
int pos2 = a[j] + 1;
if (a[j] < l) {
q = s[pos2] - '0';
while (pos2 < l - 1 && s[pos2 + 1] == '*') {
pos2 += 2;
q *= s[pos2] - '0';
}
}
long long ss = calc(0, pos1 - 2) + t * q * calc(a[i] + 1, a[j] - 1) +
calc(pos2 + 2, l - 1);
if (ss > res) res = ss;
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> con[10005];
int s = 0, dp[10005], vis[10005], b[10005];
int a[4][10005];
void rec(int k) {
vis[k] = 1;
for (int i = 0; i < con[k].size(); i++)
if (!vis[con[k][i]]) rec(con[k][i]);
b[++s] = k;
}
int main() {
int n, k, i, j, ans, x, y;
scanf("%d%d", &n, &k);
for (i = 0; i < k; i++) {
for (j = 0; j < n; j++) {
scanf("%d", &x);
a[i][x] = j;
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i != j) {
for (y = 0; y < k; y++)
if (a[y][i] > a[y][j]) break;
if (y == k) con[i].push_back(j);
}
for (i = 1; i <= n; i++)
if (!vis[i]) rec(i);
ans = 0;
for (i = 1; i <= n; i++) {
dp[b[i]] = 1;
for (j = 0; j < con[b[i]].size(); j++)
dp[b[i]] = max(dp[con[b[i]][j]] + 1, dp[b[i]]);
ans = max(ans, dp[b[i]]);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int f(int x) {
if (n - 2 * x + 2 > 0 && m - 2 * x + 2 > 0)
return ((n - 2 * x + 2) * (m - 2 * x + 2) + 1) / 2;
else
return 0;
}
int main(int argc, char *argv[]) {
int x;
cin >> n >> m >> x;
cout << f(x) - f(x + 1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int pwr(long long int base, long long int p, long long int mod) {
long long int ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int a[300005];
int n, k;
bool solve(int x) {
int dp[n + 3];
for (int i = 0; i <= n; i++) dp[i] = 0;
int curr = 0;
for (int i = k; i <= n; i++) {
int prev = dp[i - k];
if (a[i] - a[prev + 1] <= x) {
curr = i;
}
dp[i] = curr;
}
return dp[n] == n;
}
int main() {
scanf("%d", &n);
scanf("%d", &k);
for (int i = (1); i < (n + 1); ++i) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
if (k == 1) {
printf("0");
return 0;
}
int l = 0, h = 1e9;
int ans;
while (l <= h) {
int m = (l + h) / 2;
if (solve(m)) {
ans = m;
h = m - 1;
} else
l = m + 1;
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a, b, k;
bool nt[1000010];
int f[1000010];
void sang() {
for (int i = 2; i <= b; i++) nt[i] = true;
for (int i = 2; i <= (int)sqrt(b); i++)
if (nt[i]) {
int j = i + i;
while (j <= b) {
nt[j] = false;
j += i;
}
}
}
int main() {
cin >> a >> b >> k;
sang();
f[b + 1] = 0;
for (int i = b; i >= a; i--)
if (nt[i])
f[i] = f[i + 1] + 1;
else
f[i] = f[i + 1];
int res = -1;
int le = 1, ri = b - a + 1;
while (le <= ri) {
int mid = (le + ri) / 2;
bool ok = true;
for (int x = a; x <= b - mid + 1; x++) {
if (f[x] - f[x + mid] < k) {
ok = false;
break;
}
}
if (ok) {
res = mid;
ri = mid - 1;
} else
le = mid + 1;
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
inline int rdi() {
int v;
cin >> v;
return v;
}
inline long long rdll() {
long long v;
cin >> v;
return v;
}
inline string rds() {
string s;
cin >> s;
return s;
}
inline char rdc() {
char c;
cin >> c;
return c;
}
template <class T>
void rdv(T beg_iter, T end_iter) {
for (; beg_iter != end_iter; ++beg_iter) cin >> *beg_iter;
}
inline void wri(const int v) { cout << v; }
inline void wrll(const long long& v) { cout << v; }
inline void wrs(const string& s) { cout << s; }
inline void wrc(const char c) { cout << c; }
template <class T>
void wrv(T beg_iter, T end_iter, string separator = " ",
string end_of_line = "\n") {
for (; beg_iter != end_iter; ++beg_iter) {
cout << *beg_iter;
cout << separator;
}
cout << end_of_line;
}
} // namespace io
using namespace io;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
x = (x * x) % p;
}
return res;
}
void solve();
int main() {
int t = 1;
while (t--) solve();
return 0;
}
void solve() {
int n = rdi(), m = rdi();
vector<pair<int, int>> A;
for (int i = 0; i < m; ++i) {
int a = rdi(), b = rdi();
A.push_back(make_pair(a, b));
}
int x1 = A[0].first, x2 = A[0].second;
int y1 = x1, y2 = x2;
for (int i = 1; i < m; ++i) {
if (A[i].first != x1 && A[i].second != x1) {
y1 = A[i].first;
y2 = A[i].second;
break;
}
}
bool flag = 1;
for (int i = 1; i < m; ++i) {
if (A[i].first != x1 && A[i].second != x1 && A[i].first != y1 &&
A[i].second != y1) {
flag = 0;
break;
}
}
if (flag == 1) {
cout << "YES" << '\n';
return;
}
flag = 1;
for (int i = 1; i < m; ++i) {
if (A[i].first != x1 && A[i].second != x1 && A[i].first != y2 &&
A[i].second != y2) {
flag = 0;
break;
}
}
if (flag == 1) {
cout << "YES" << '\n';
return;
}
for (int i = 1; i < m; ++i) {
if (A[i].first != x2 && A[i].second != x2) {
y1 = A[i].first;
y2 = A[i].second;
break;
}
}
flag = 1;
for (int i = 1; i < m; ++i) {
if (A[i].first != x2 && A[i].second != x2 && A[i].first != y1 &&
A[i].second != y1) {
flag = 0;
break;
}
}
if (flag == 1) {
cout << "YES" << '\n';
return;
}
flag = 1;
for (int i = 1; i < m; ++i) {
if (A[i].first != x2 && A[i].second != x2 && A[i].first != y2 &&
A[i].second != y2) {
flag = 0;
break;
}
}
if (flag == 1) {
cout << "YES" << '\n';
return;
}
cout << "NO" << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, a[12], i, m = 0;
cin >> k;
for (i = 0; i < 12; i++) cin >> a[i];
sort(a, a + 12);
if (k == 0)
cout << "0";
else {
for (i = 11; i >= 0; i--) {
k -= a[i];
m++;
if (k <= 0) break;
}
if (k <= 0)
cout << m;
else
cout << "-1";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int w[1005], b[1005];
vector<int> g[1005];
bool visited[1005];
int k;
vector<int> ans[1005];
vector<pair<int, int> > res[1005];
int dp[1005][1005];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void dfs(int v, int pr) {
int sz = g[v].size();
ans[k].push_back(v);
visited[v] = true;
for (int j = 0; j < sz; j++) {
int u = g[v][j];
if (u == pr) continue;
if (visited[u]) continue;
dfs(u, v);
}
}
int main() {
int n, m, ww;
k = 0;
cin >> n >> m >> ww;
int i;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
cin >> w[i];
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
cin >> b[i];
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
visited[i] = false;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
g[i].clear();
int foo, bar;
for (__typeof(m) i = (0) - ((0) > (m)); i != (m) - ((0) > (m));
i += 1 - 2 * ((0) > (m))) {
cin >> foo >> bar;
bar--;
foo--;
g[foo].push_back(bar);
g[bar].push_back(foo);
}
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
if (!visited[i]) {
dfs(i, -1);
k++;
}
}
int j;
for (__typeof(k) i = (0) - ((0) > (k)); i != (k) - ((0) > (k));
i += 1 - 2 * ((0) > (k))) {
int wg = 0;
int be = 0;
if (ans[i].size() != 1) {
for (__typeof(ans[i].size()) j = (0) - ((0) > (ans[i].size()));
j != (ans[i].size()) - ((0) > (ans[i].size()));
j += 1 - 2 * ((0) > (ans[i].size()))) {
res[i].push_back(make_pair(w[ans[i][j]], b[ans[i][j]]));
wg += w[ans[i][j]];
be += b[ans[i][j]];
}
res[i].push_back(make_pair(wg, be));
} else
res[i].push_back(make_pair(w[ans[i][0]], b[ans[i][0]]));
}
int l;
for (__typeof(k + 1) i = (0) - ((0) > (k + 1));
i != (k + 1) - ((0) > (k + 1)); i += 1 - 2 * ((0) > (k + 1))) {
for (__typeof(ww + 1) j = (0) - ((0) > (ww + 1));
j != (ww + 1) - ((0) > (ww + 1)); j += 1 - 2 * ((0) > (ww + 1)))
dp[i][j] = 0;
}
for (__typeof(ww + 1) j = (0) - ((0) > (ww + 1));
j != (ww + 1) - ((0) > (ww + 1)); j += 1 - 2 * ((0) > (ww + 1)))
dp[0][j] = 0;
for (__typeof(k + 1) i = (1) - ((1) > (k + 1));
i != (k + 1) - ((1) > (k + 1)); i += 1 - 2 * ((1) > (k + 1))) {
for (__typeof(res[i - 1].size()) l = (0) - ((0) > (res[i - 1].size()));
l != (res[i - 1].size()) - ((0) > (res[i - 1].size()));
l += 1 - 2 * ((0) > (res[i - 1].size()))) {
for (__typeof(ww + 1) j = (0) - ((0) > (ww + 1));
j != (ww + 1) - ((0) > (ww + 1)); j += 1 - 2 * ((0) > (ww + 1))) {
if (i == 0 || j == 0)
dp[i][j] = 0;
else {
if (res[i - 1][l].first <= j)
dp[i][j] =
((dp[i][j]) >
(((dp[i - 1][j]) >
(res[i - 1][l].second + dp[i - 1][j - res[i - 1][l].first]))
? (dp[i - 1][j])
: (res[i - 1][l].second +
dp[i - 1][j - res[i - 1][l].first])))
? (dp[i][j])
: (((dp[i - 1][j]) > (res[i - 1][l].second +
dp[i - 1][j - res[i - 1][l].first]))
? (dp[i - 1][j])
: (res[i - 1][l].second +
dp[i - 1][j - res[i - 1][l].first]));
else
dp[i][j] =
((dp[i][j]) > (dp[i - 1][j])) ? (dp[i][j]) : (dp[i - 1][j]);
}
}
}
}
cout << dp[k][ww];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define mod 1000000007
#define vll vector<ll>
#define pll vector<pair<ll,ll>>
ll gr[200001];
ll pref[200001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
t=1;
cin>>t;
start:
while(t--){
ll n;
cin>>n;
ll arr[n+1];
map<ll,ll> ct;
for(ll i=1;i<=n;i++){
cin>>arr[i];
ct[arr[i]]++;
}
memset(gr,0,sizeof gr);
memset(pref,0,sizeof pref);
set<ll> st;
for(auto i:ct){
gr[i.s]++;
st.insert(i.s);
}
ll pr=0;
for(auto i=st.rbegin();i!=st.rend();i++){
pr+=gr[*i];
pref[*i]=pr;
}
ll mn=1e8;
for(ll i=0;i<=*st.rbegin();i++){
ll val=i*pref[i];
mn=min(mn,n-val);
}
cout<<mn<<endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 100;
const long long MOD = 1e9 + 7;
bool vis[N];
vector<long long> adj[N];
void dfs(long long cur) {
vis[cur] = true;
for (auto v : adj[cur]) {
if (!vis[v]) dfs(v);
}
}
int main() {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long> > v;
set<long long> st;
for (int i = 0; i < k; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
st.insert(a);
st.insert(b);
}
long long co = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
co++;
dfs(i);
}
}
cout << k - n + co << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 60;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int MOD = 1000000007;
const double eps = 1e-7;
void print(int x) {
cout << x << endl;
exit(0);
}
void PRINT(string x) {
cout << x << endl;
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
int dp[N * 2][2][N][N * 2];
int ans, n, m;
string s;
void dfs(int x, int dir, int num, int val) {
if (dp[x][dir][num][val] || x > n || num > m) return;
dp[x][dir][num][val] = 1;
if (x == n && num == m) {
ans = max(ans, abs(val));
return;
}
dfs(x + 1, dir, num + (s[x] == 'T'), val + (dir ? -1 : 1));
dfs(x + 1, 1 - dir, num + (s[x] == 'F'), val);
dfs(x, dir, num + 2, val);
}
signed main() {
cin >> s >> m;
n = ((int)s.size());
dfs(0, 0, 0, 0);
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[200010], cnt, n;
bool vis[200010];
int ans[200010];
struct node {
int num, step;
};
void solve(int x, int y) {
queue<node> q;
node tmp;
tmp.num = 1;
tmp.step = 0;
memset(vis, false, sizeof(vis));
vis[tmp.num] = true;
q.push(tmp);
while (!q.empty()) {
node tp = q.front();
q.pop();
if (tp.num >= 1 && tp.num <= n) {
ans[tp.num] = tp.step;
cnt++;
}
if (cnt > y) return;
for (int i = 0; i < 3; i++) {
node tt;
if (i == 1) {
if (a[tp.num] == tp.num)
continue;
else {
tt.num = a[tp.num];
if (!vis[tt.num] && tt.num > 0 && tt.num <= 200000) {
vis[tt.num] = true;
tt.step = tp.step + 1;
q.push(tt);
}
}
} else if (i == 0) {
tt.num = tp.num + 1;
if (!vis[tt.num] && tt.num > 0 && tt.num <= 200000) {
vis[tt.num] = true;
tt.step = tp.step + 1;
q.push(tt);
}
} else {
tt.num = tp.num - 1;
if (!vis[tt.num] && tt.num > 0 && tt.num <= 200000) {
vis[tt.num] = true;
tt.step = tp.step + 1;
q.push(tt);
}
}
}
}
}
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cnt = 1;
solve(1, n);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[14000];
bool ok;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i)
if (a[i] % 2 == 0)
cout << a[i] / 2 << "\n";
else if (!ok) {
if (a[i] < 0)
cout << a[i] / 2 << "\n";
else
cout << a[i] / 2 + 1 << "\n";
ok = 1;
} else {
if (a[i] < 0)
cout << a[i] / 2 - 1 << "\n";
else
cout << a[i] / 2 << "\n";
ok = 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char str[300005];
int main() {
scanf("%s", str + 1);
int n = strlen(str + 1), minn = n + 1;
long long ans = 0;
for (int i = n; i > 0; i--) {
for (int j = 1; i + 2 * j < minn; j++)
if (str[i] == str[i + j] && str[i + j] == str[i + 2 * j]) {
minn = i + 2 * j;
break;
}
ans += n - minn + 1;
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int GLL(long long& x) { return scanf("%lld", &x); }
int GI(int& x) { return scanf("%d", &x); }
const int MAXN = 100005;
int a[MAXN], dp[MAXN];
vector<pair<int, int> > ai;
int n;
int main() {
GI(n);
for (int i = 1; i <= (int)(n); i++) {
GI(a[i]);
ai.push_back(make_pair(a[i], i));
}
memset(dp, -1, sizeof dp);
sort(ai.rbegin(), ai.rend());
for (auto p : ai) {
int i = p.second;
dp[i] = 0;
for (int j = i - a[i]; j >= 1; j -= a[i]) {
if (a[j] > a[i] && dp[j] == 0) {
dp[i] = 1;
}
}
for (int j = i + a[i]; j <= n; j += a[i]) {
if (a[j] > a[i] && dp[j] == 0) {
dp[i] = 1;
}
}
}
for (int i = 1; i <= (int)(n); i++) {
if (dp[i])
printf("A");
else
printf("B");
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 1e5 + 5;
const double eps = 1e-9;
using namespace std;
vector<int> adj[MAXN], nadj[MAXN];
int low[MAXN], disc[MAXN], comp[MAXN], U[MAXN], V[MAXN], sz[MAXN];
int par[18][MAXN], cnt[18][MAXN], depth[MAXN];
bool inStack[MAXN], vis[MAXN];
int t = 0, cur = 0;
stack<int> st;
long long bin(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = (a * r) % MOD;
a = (a * a) % MOD;
b /= 2ll;
}
return r;
}
void dfs(int u, int p) {
disc[u] = low[u] = t++;
vis[u] = 1;
inStack[u] = 1;
st.push(u);
for (int v : adj[u]) {
if (!vis[v]) {
dfs(v, u);
low[u] = min(low[u], low[v]);
} else if (v != p && inStack[v])
low[u] = min(low[u], disc[v]);
}
if (low[u] == disc[u]) {
int v = -1;
do {
v = st.top();
comp[v] = cur;
sz[cur]++;
st.pop();
} while (v != u);
cur++;
}
}
void ndfs(int u, int p) {
for (int v : nadj[u]) {
if (v == p) continue;
depth[v] = depth[u] + 1;
par[0][v] = u;
cnt[0][v] = (sz[u] > 1);
ndfs(v, u);
}
}
long long lca(int u, int v) {
long long ret = 0;
if (depth[u] > depth[v]) swap(u, v);
int x = u, y = v;
int d = depth[v] - depth[u];
for (int i = 0; i < 18; i++)
if ((d >> i) & 1) {
ret += cnt[i][v];
v = par[i][v];
}
if (u == v) return ret + (sz[y] > 1);
for (int i = 17; i >= 0; i--)
if (par[i][u] != par[i][v]) {
ret += cnt[i][v] + cnt[i][u];
v = par[i][v], u = par[i][u];
}
return cnt[0][u] + ret + (sz[x] > 1) + (sz[y] > 1);
}
int main() {
int n, m;
scanf("%d", &(n)), scanf("%d", &(m));
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d", &(u)), scanf("%d", &(v));
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
U[i] = u, V[i] = v;
}
dfs(0, -1);
for (int i = 0; i < m; i++)
if (comp[U[i]] != comp[V[i]]) {
nadj[comp[U[i]]].push_back(comp[V[i]]);
nadj[comp[V[i]]].push_back(comp[U[i]]);
}
ndfs(0, -1);
for (int i = 1; i < 18; i++) {
for (int j = 0; j < n; j++) {
par[i][j] = par[i - 1][par[i - 1][j]];
cnt[i][j] = cnt[i - 1][j] + cnt[i - 1][par[i - 1][j]];
}
}
int k;
scanf("%d", &(k));
while (k--) {
int u, v;
scanf("%d", &(u)), scanf("%d", &(v));
u--, v--;
long long tmp = lca(comp[u], comp[v]);
printf("%I64d\n", (bin(2, tmp)));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
vector<vector<int>> g(N, vector<int>());
for (int i = 0; i < n; i++) {
cin >> a[i];
g[a[i]].push_back(i);
}
int res = 0;
for (int i = 1; i < N; i++) {
if (g[i].empty()) continue;
int sz = (int)g[i].size();
res = max(res, sz);
for (int j = 0; j < sz / 2; j++) {
int L = g[i][j], R = g[i][sz - j - 1];
for (int mid = 1; mid < N; mid++) {
if (g[mid].empty() or mid == i) continue;
int st =
upper_bound(g[mid].begin(), g[mid].end(), L) - g[mid].begin();
int en =
upper_bound(g[mid].begin(), g[mid].end(), R) - g[mid].begin();
--en;
int len = 2 * (j + 1) + max(0, en - st + 1);
res = max(res, len);
}
}
}
cout << res << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, ans = 0, out = 0, b = -1;
string s;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == '(')
ans++;
else
ans--;
if (ans < 0 && b == -1) b = i;
if (!ans && ~b) out += i - b + 1, b = -1;
}
cout << (ans ? -1 : out);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 5;
const int mod = 1e9 + 7;
int dp[N][N];
int ans[N];
int pal[N][N];
int main() {
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < n; i++) {
pal[i][i] = 1;
dp[i][i] = 1;
ans[1]++;
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i < n; i++) {
int j = i + len - 1;
pal[i][j] = (i < n and j < n and s[i] == s[j] &&
((i + 1 <= j - 1) ? pal[i + 1][j - 1] : 1));
if (pal[i][j]) {
dp[i][j] = dp[i][i + len / 2 - 1] + 1;
ans[dp[i][j]]++;
} else
dp[i][j] = 0;
}
}
for (int i = n; i >= 1; i--) ans[i] += ans[i + 1];
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, le;
vector<int> g[107], s;
bool odw[107], czy[107];
void dfs(int s) {
odw[s] = 1;
le++;
for (int i = 0; i < (int)g[s].size(); i++) {
int u = g[s][i];
if (!odw[u]) dfs(u);
}
}
long long nww(int a, int b) {
int d = a, p = b;
while (b != 0) {
int c = a % b;
a = b, b = c;
}
return (long long)(d * p) / (long long)a;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
g[i].push_back(a);
czy[a] = 1;
}
for (int i = 1; i <= n; i++) {
if (czy[i] == 0) {
puts("-1");
return 0;
}
}
for (int i = 1; i <= n; i++) {
if (!odw[i]) {
le = 0;
dfs(i);
if (le % 2 == 0)
s.push_back(le / 2);
else
s.push_back(le);
}
}
long long w = s[0];
for (int i = 0; i < (int)s.size(); i++) w = nww(w, s[i]);
printf("%lld", w);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string t;
cin >> t;
if (n == k) {
} else {
int y = 0;
while (k > 0 && y < 26) {
for (int i = 0; i < t.size(); i++) {
if (k <= 0)
break;
else if ((int)t[i] == y + 'a') {
t[i] = 'D';
k--;
}
}
y++;
}
for (int i = 0; i < t.size(); i++) {
if (t[i] != 'D') cout << t[i];
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
const int N = 4000 + 2;
int dp[N][N], n, m, k, l[N], r[N], sum[N], s[N], sum2[N];
int inter(int l1, int r1, int l2, int r2) {
return std::max(0, std::min(r1, r2) - std::max(l1, l2) + 1);
}
void PUNKS_NOT_DEAD() {
std::cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
std::cin >> l[i] >> r[i];
}
int best = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int keep = inter(i, i + k - 1, l[j], r[j]);
s[i] += keep;
int max = std::min(r[j] - l[j] + 1, k);
if (keep == max) continue;
if (i < l[j]) {
sum[std::max(i + 1, l[j] - (k - 1))]++, sum[std::min(l[j], r[j] - (k - 1)) + 1]--;
//std::cout << std::max(i + 1, l[j] - (k - 1)) << ' ' << std::min(l[j], r[j] - (k - 1)) + 1 << '\n';
assert(std::max(i + 1, l[j] - (k - 1)) <= std::min(l[j], r[j] - (k - 1)) + 1);
sum[r[j] - (max - 1) + 1]--, sum[r[j] - (keep - 1) + 1]++;
} else {
sum2[std::min(i - 1, r[j])]++, sum2[r[j] - (max - 1) - 1]--;
sum2[std::min(l[j], r[j] - (max - 1)) - 1]--, sum2[std::max(0, l[j] + (keep - 1) - k)]++;
}
}
for (int j = 1; j <= n; j++) sum[j] += sum[j - 1];
for (int j = 1; j <= n; j++) sum[j] += sum[j - 1];
for (int j = n; j >= 1; j--) sum2[j] += sum2[j + 1];
for (int j = n; j >= 1; j--) sum2[j] += sum2[j + 1];
for (int j = 1; j <= n; j++) {
best = std::max(best, s[i] + sum[j] + sum2[j]);
sum[j] = 0;
sum2[j] = 0;
}
}
std::cout << best;
}
signed main() {
std::ios_base::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
PUNKS_NOT_DEAD();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
string s;
struct Tree {
int c0, c1, c;
} tree[maxn << 2];
void pushup(int rt) {
tree[rt].c0 = tree[rt << 1].c0 + tree[rt << 1 | 1].c0;
tree[rt].c1 = tree[rt << 1].c1 + tree[rt << 1 | 1].c1;
tree[rt].c = max(tree[rt << 1].c + tree[rt << 1 | 1].c1,
tree[rt << 1].c0 + tree[rt << 1 | 1].c);
}
void buildtree(int rt, int l, int r) {
if (l == r) {
tree[rt].c = 1;
if (s[l - 1] == '0')
tree[rt].c0 = 1, tree[rt].c1 = 0;
else
tree[rt].c1 = 1, tree[rt].c0 = 0;
return;
}
int mid = (l + r) >> 1;
buildtree(rt << 1, l, mid);
buildtree(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void update(int rt, int l, int r, int p, int val) {
if (l == r) {
if (val)
tree[rt].c1 = 1, tree[rt].c0 = 0;
else
tree[rt].c0 = 1, tree[rt].c1 = 0;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(rt << 1, l, mid, p, val);
else
update(rt << 1 | 1, mid + 1, r, p, val);
pushup(rt);
}
int main() {
cin >> s;
int n = s.size();
buildtree(1, 1, n);
int c = tree[1].c;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
update(1, 1, n, i + 1, 0);
if (tree[1].c == c)
s[i] = '0';
else
update(1, 1, n, i + 1, 1);
}
}
cout << s << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s[70005], Ti;
unordered_map<string, int> seg, subseg[70005];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
for (int j = 0; j <= 8; j++) {
for (int k = j; k <= 8; k++) {
seg[s[i].substr(j, k - j + 1)]++;
subseg[i][s[i].substr(j, k - j + 1)]++;
}
}
}
for (int i = 1; i <= n; i++) {
bool done = 0;
for (int j = 1; j <= 9; j++) {
for (int k = 0; k <= 8 - j + 1; k++) {
Ti = s[i].substr(k, j);
int t = seg[Ti] - subseg[i][Ti];
if (t == 0) {
cout << Ti << endl;
done = 1;
break;
}
}
if (done) break;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x + _y;
if (_ >= _mod) _ -= _mod;
return _;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x - _y;
if (_ < 0) _ += _mod;
return _;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x * _y;
if (_ >= _mod) _ %= _mod;
return _;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1ll;
long long _tmp = mypow(_a, _x / 2, _mod);
_tmp = mul(_tmp, _tmp, _mod);
if (_x & 1) _tmp = mul(_tmp, _a, _mod);
return _tmp;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0ll;
long long _tmp = mymul(_a, _x / 2, _mod);
_tmp = add(_tmp, _tmp, _mod);
if (_x & 1) _tmp = add(_tmp, _a, _mod);
return _tmp;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int __ = 1, _cs;
void build() {}
long long d, h, v, e;
long double pi = acos(-1.0);
void init() {
d = getint();
h = getint();
v = getint();
e = getint();
}
void solve() {
if (4 * v <= (long long)(d * d * e * pi))
puts("NO");
else {
puts("YES");
printf("%.12f\n", (double)((long double)h /
((4.0 * (long double)v / (d * d * pi)) - e)));
}
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, mod = 998244353;
long long dp1[maxn], dp2[maxn], dp3[maxn], pd1, pd2, pd3;
vector<int> adj[maxn];
int add(long long a, long long b) { return (a + b) % mod; }
int mul(long long a, long long b) { return (a * b) % mod; }
void dfs(int v, int par) {
dp2[v] = dp3[v] = 1;
for (auto u : adj[v]) {
if (u == par) continue;
dfs(u, v);
pd3 = add(pd3, mul(dp3[v], add(dp1[u], dp3[u])));
pd2 = add(pd2, mul(dp2[v], add(dp1[u], dp3[u])));
pd2 = add(pd2, mul(dp2[v], dp1[u]));
pd1 = add(pd1, mul(dp1[v], add(dp1[u], dp3[u])));
pd1 = add(pd1, add(mul(dp1[v], dp1[u]), mul(dp2[v], dp2[u])));
dp1[v] = pd1, dp2[v] = pd2, dp3[v] = pd3;
pd1 = pd2 = pd3 = 0;
}
return;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
cout << add(dp1[1], dp3[1]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, a[1010][1010];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
char f[4] = {'L', 'U', 'R', 'D'};
char ans[1010][1010];
queue<int> q;
int id(int x, int y) { return (x + 1) * 1010 + y; }
void rua(int x, int y) {
if (ans[x][y] != 'I') return;
if (a[x][y] < 0)
for (int i = 0; i < 4; i++) {
int nxtx = x + dx[i], nxty = y + dy[i];
if (nxtx < 1 || nxtx > n || nxty < 1 || nxty > n) continue;
if (a[nxtx][nxty] == a[x][y]) {
ans[nxtx][nxty] = f[i];
ans[x][y] = f[(i + 2) % 4];
break;
}
}
else
ans[x][y] = 'X', q.push(id(x, y));
while (!q.empty()) {
int cur = q.front();
q.pop();
x = cur / 1010 - 1, y = cur % 1010;
for (int i = 0; i < 4; i++) {
int nxtx = x + dx[i], nxty = y + dy[i];
if (nxtx < 1 || nxtx > n || nxty < 1 || nxty > n) continue;
if (a[nxtx][nxty] == a[x][y] && ans[nxtx][nxty] == 'I')
ans[nxtx][nxty] = f[i], q.push(id(nxtx, nxty));
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
scanf("%d%d", &x, &y);
a[i][j] = id(x, y);
ans[i][j] = 'I';
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i][j] == id(i, j) || a[i][j] < 0) rua(i, j);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (ans[i][j] == 'I') return printf("INVALID\n"), 0;
printf("VALID\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%c", ans[i][j]);
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<long long, long long> pll;
int main() {
int n;
cin >> n;
map<int, bool> processed;
processed[0] = true;
int the_time = 0;
for (int i = int(1); i <= int(n); i++) {
int a;
cin >> a;
if (processed[a]) continue;
processed[a] = true;
the_time += 1;
}
cout << the_time << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tostr(const T& t) {
ostringstream os;
os << t;
return os.str();
}
vector<int> cache[12][12];
const int mod = 1000000007;
void add(vector<int>& v, const vector<int>& w) {
for (int i = (int)(0); i <= (int)(12 - 1); ++i) v[i] += w[i];
}
vector<int> cnt47(int digits, int already47) {
if (digits == 0) {
vector<int> v(12, 0);
v[already47] = 1;
return v;
}
if (!cache[digits][already47].empty()) {
return cache[digits][already47];
}
vector<int> v(12, 0);
for (int d = (int)(0); d <= (int)(10 - 1); ++d) {
int e = (d == 4 || d == 7) ? 1 : 0;
add(v, cnt47(digits - 1, already47 + e));
}
return cache[digits][already47] = v;
}
vector<int> V;
long long ways(int parties, int rem47) {
if (parties == 0) return 1;
long long sum = 0;
for (int i = 0; i <= rem47 && V[i] > 0; ++i) {
V[i] -= 1;
sum += (V[i] + 1) * ways(parties - 1, rem47 - i);
sum %= mod;
V[i] += 1;
}
return sum;
}
int main() {
char buf[16];
scanf("%s", buf);
vector<int> v(12, 0);
int already47 = 0;
int len = strlen(buf);
for (int i = (int)(0); i <= (int)(len - 1); ++i) {
int d = buf[i] - '0';
int lim = (i + 1 == len) ? d + 1 : d;
for (int j = (int)(0); j <= (int)(lim - 1); ++j) {
int e = (j == 4 || j == 7) ? 1 : 0;
add(v, cnt47(len - i - 1, already47 + e));
}
if (d == 4 || d == 7) {
++already47;
}
}
v[0] -= 1;
V = v;
long long w = 0;
for (int i = 1; i < 12 && v[i] > 0; ++i) {
w += v[i] * ways(6, i - 1);
w %= mod;
}
printf("%d\n", (int)(w % mod));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
cout << ((i % 2 == 0 or j == (m - 1) * (1 - i / 2 % 2)) ? '#' : '.');
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, inside = 0, outside = 0, p = 0, cnt = 0, cnt1 = 0;
scanf("%d", &n);
char s[255];
scanf("%s", s);
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
p = 1;
if (cnt) {
outside = max(outside, cnt);
cnt = 0;
}
} else if (s[i] == ')') {
p = 0;
if (cnt1) inside++;
cnt1 = 0;
} else if (s[i] != '_') {
if (p)
cnt1++;
else
cnt++;
} else {
if (cnt1) {
inside++;
cnt1 = 0;
} else {
outside = max(outside, cnt);
cnt = 0;
}
}
}
if (cnt1) inside++;
if (cnt) outside = max(outside, cnt);
printf("%d %d", outside, inside);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, x, y;
cin >> a >> b >> x >> y;
cout << max({a * (b - y - 1), a * y, b * (a - x - 1), b * x}) << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x1, x2, y2, y1, r1, r2, ma, mi;
double dis;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
dis = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
ma = max(r1, r2);
mi = min(r1, r2);
if (dis >= ma - mi && dis <= r1 + r2)
cout << 0;
else if (dis < ma - mi)
printf("%.10lf", (double)(-dis + ma - mi) / 2.0);
else
printf("%.10lf", (double)(dis - r1 - r2) / 2.0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int INF = 1E9;
const int MAXN = 5050;
const long long LINF = 1E18;
int n, s, f;
int x[MAXN], a[MAXN], b[MAXN], c[MAXN], d[MAXN], dist[MAXN];
long long dp[2][MAXN][2][2];
bool upd(long long &x, long long y) {
if (x > y) {
x = y;
return 1;
}
return 0;
}
int main() {
cin >> n >> s >> f;
s--, f--;
for (int i = 0; i < (int)(n); i++) cin >> x[i];
for (int i = 0; i < (int)(n - 1); i++) dist[i] = x[i + 1] - x[i];
for (int i = 0; i < (int)(n); i++) cin >> a[i];
for (int i = 0; i < (int)(n); i++) cin >> b[i];
for (int i = 0; i < (int)(n); i++) cin >> c[i];
for (int i = 0; i < (int)(n); i++) cin >> d[i];
for (int i = 0; i < (int)(2); i++)
for (int j = 0; j < (int)(MAXN); j++)
for (int from = 0; from < (int)(2); from++)
for (int to = 0; to < (int)(2); to++) dp[i][j][from][to] = LINF;
dp[0][0][0][0] = 0;
for (int i = 0; i < n; i++) {
int id = i & 1;
int nid = id ^ 1;
for (int j = 0; j <= n; j++)
for (int from = 0; from < (int)(2); from++)
for (int to = 0; to < (int)(2); to++) {
long long cur = dp[id][j][from][to];
if (cur < LINF) {
if (i == s) {
assert(!to);
upd(dp[nid][j][from][1], cur + d[i]);
if (j > 0) upd(dp[nid][j - 1][from][1], cur + c[i]);
if (i == n - 1 && from) upd(dp[nid][j][0][0], cur + c[i]);
} else if (i == f) {
assert(!from);
upd(dp[nid][j][1][to], cur + b[i]);
if (j > 0) upd(dp[nid][j - 1][1][to], cur + a[i]);
if (i == n - 1 && to) upd(dp[nid][j][0][0], cur + a[i]);
} else {
upd(dp[nid][j + 1][from][to], cur + b[i] + d[i]);
if (j > 1 || (j == 1 && from + to > 0))
upd(dp[nid][j - 1][from][to], cur + a[i] + c[i]);
if (i == n - 1 && from && to)
upd(dp[nid][j][0][0], cur + a[i] + c[i]);
if (j + to) upd(dp[nid][j][from][to], cur + a[i] + d[i]);
if (j + from) upd(dp[nid][j][from][to], cur + b[i] + c[i]);
}
}
}
for (int j = 0; j <= n; j++)
for (int from = 0; from < (int)(2); from++)
for (int to = 0; to < (int)(2); to++) {
dp[id][j][from][to] = LINF;
if (dp[id ^ 1][j][from][to] < LINF)
dp[id ^ 1][j][from][to] += 1ll * (2 * j + from + to) * dist[i];
}
}
cout << dp[n & 1][0][0][0] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, r, k;
long long a[500005], b[500005], cnt[500010];
bool check(long long h) {
fill(cnt, cnt + 500010, 0);
long long tmp = 0, use = 0;
for (int i = 1; i <= n; i++) {
tmp -= cnt[i];
cnt[i] = 0;
if (a[i] + tmp < h) {
long long e = h - a[i] - tmp;
tmp += e;
use += e;
if (use > k) {
break;
}
if (i + r + r + 1 <= n) cnt[i + r + r + 1] += e;
}
}
return use <= k;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> r >> k;
for (int i = 1; i <= n; i++) cin >> a[i], b[i] = a[i];
long long tmp = 0;
for (int i = 1; i <= n; i++) {
a[i] += tmp;
if (i > r) tmp -= b[i - r];
tmp += b[i];
}
tmp = 0;
for (int j = n; j >= 1; j--) {
a[j] += tmp;
if (j <= n - r) tmp -= b[j + r];
tmp += b[j];
}
long long L = 0, R = (1LL << 60);
while (R - L != 1) {
long long M = (L + R) / 2;
if (check(M))
L = M;
else
R = M;
}
cout << L << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int A[n];
for (int i = 0; i < n; i++) cin >> A[i];
sort(A, A + n);
cout << A[n - a] - A[n - a - 1];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[100005];
int n, l, r;
while ((scanf("%c", &s[++n]) == 1) && (s[n] >= '0') && (s[n] <= '9'))
s[n] -= '0';
l = 1;
r = --n;
if (s[l] != s[r]) {
s[l]--;
s[l + 1] += 10;
if (s[l] == 0) l++;
}
while (l <= r) {
if (s[l] != s[r]) {
if ((s[l] - s[r] >= 10) && (s[r] < 10)) {
s[r - 1]--;
s[r] += 10;
}
if (s[l] - s[r] == 1) {
s[l]--;
s[l + 1] += 10;
}
}
if (s[l] != s[r]) break;
if (l != r) {
s[l] = s[l] - (s[r] >> 1);
s[r] >>= 1;
} else if (((s[l] >> 1) << 1) == s[l])
s[l] >>= 1;
else
break;
if (s[l] > 9 || s[l] < 0 || s[r] > 9 || s[r] < 0) break;
l++;
r--;
}
if (l <= r) {
printf("0");
return 0;
}
l = 1;
if (s[l] == 0) l++;
while (l <= n) {
printf("%d", s[l]);
l++;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const long long MOD = 1000000007;
const long long inf = 1e18;
using namespace std;
long long int modpow(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
long long int sq(long long int x1, long long int y1) {
return x1 * x1 + y1 * y1;
}
void always_ignore_function_name() {
int n, q;
cin >> n >> q;
std::vector<long long int> v(1 << n);
long double a = 0;
for (int i = 0; i < (1 << n); i++) {
cin >> v[i];
a += v[i];
}
cout << setprecision(10) << a / (1 << n) << endl;
while (q--) {
int x, y;
cin >> x >> y;
a += y - v[x];
v[x] = y;
cout << setprecision(10) << a / (1 << n) << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int t = 1, tt = 1;
while (tt <= t) {
always_ignore_function_name();
tt++;
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 8 |
#include <bits/stdc++.h>
template <typename T, typename U>
std::istream& operator>>(std::istream& input, std::pair<T, U>& v) {
return input >> v.first >> v.second;
}
template <typename T>
std::istream& operator>>(std::istream& input, std::vector<T>& v) {
for (T& a : v) input >> a;
return input;
}
void answer(int v) { std::cout << v << '\n'; }
void solve(const std::vector<std::pair<unsigned, unsigned>>& c, unsigned x) {
const size_t n = c.size();
unsigned l = std::min(c[0].first, c[0].second);
unsigned r = std::max(c[0].first, c[0].second);
for (size_t i = 1; i < n; ++i) {
l = std::max(l, std::min(c[i].first, c[i].second));
r = std::min(r, std::max(c[i].first, c[i].second));
}
if (l > r) return answer(-1);
if (l <= x && x <= r) return answer(0);
answer(x < l ? l - x : x - r);
}
int main() {
size_t n;
std::cin >> n;
unsigned x;
std::cin >> x;
std::vector<std::pair<unsigned, unsigned>> d(n);
std::cin >> d;
solve(d, x);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long ans = 0;
for (long long weight = 0; weight <= 2 * a[n - 1]; weight++) {
long long count = 0;
long long temp[n];
for (long long i = 0; i < n; i++) {
temp[i] = a[i];
}
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (temp[i] + temp[j] == weight && temp[i] > 0 && temp[j] > 0) {
count++;
temp[i] = 0;
temp[j] = 0;
break;
}
}
}
ans = max(ans, count);
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int t, n, i;
cin >> t;
while (t--) {
cin >> n;
long long int s[n];
for (i = 0; i < n; i++) cin >> s[i];
for (i = n - 1; i >= 0; i--) cout << s[i] << " ";
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
bool f(const std::vector<int>& v) {
for (int i = 0; i < v.size(); ++i) {
if (v[i] != i) return false;
}
return true;
}
int main() {
int n;
std::cin >> n;
std::vector<int> sequence(n);
for (int i = 0; i < n; ++i) {
std::cin >> sequence[i];
}
bool ok = false;
for (int i = 0; i < n; ++i) {
if (f(sequence)) {
ok = true;
break;
} else {
for (int j = 0; j < n; ++j) {
if (j % 2 == 0) {
sequence[j] = (sequence[j] + 1) % n;
} else {
sequence[j] = (sequence[j] - 1 + n) % n;
}
}
}
}
std::cout << (ok ? "Yes" : "No") << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200000];
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
vector<int> d(a, a + n);
sort(d.begin(), d.end());
d.resize(unique(d.begin(), d.end()) - d.begin());
vector<vector<int>> oc(d.size());
for (int i = 0; i < n; ++i) {
a[i] = lower_bound(d.begin(), d.end(), a[i]) - d.begin();
oc[a[i]].push_back(i);
}
auto calc = [&](vector<int> &v) {
int cur = 0;
for (int i : v) cur += oc[i].size();
int l = v[0], r = v.back();
if (l > 0)
for (int i : oc[l - 1])
if (i < oc[l][0]) ++cur;
if (r + 1 < d.size())
for (int i : oc[r + 1])
if (i > oc[r].back()) ++cur;
return cur;
};
int ans = n;
for (int i = 0, j; i < d.size(); i = j) {
vector<int> cur = {i};
for (j = i + 1; j < d.size(); ++j) {
if (oc[j][0] > oc[j - 1].back())
cur.push_back(j);
else
break;
}
ans = min(ans, n - calc(cur));
}
for (int i = 0; i + 1 < d.size(); ++i) {
vector<int> v(oc[i].size() + oc[i + 1].size());
merge(oc[i].begin(), oc[i].end(), oc[i + 1].begin(), oc[i + 1].end(),
v.begin());
int cnt0 = 0, cnt1 = 0;
for (int &j : v) {
j = a[j] - i;
assert(j == 0 || j == 1);
if (j == 1) ++cnt1;
}
int cur = cnt1;
for (int j : v) {
if (j == 0)
++cnt0;
else
--cnt1;
cur = max(cur, cnt0 + cnt1);
}
ans = min(ans, n - cur);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int vis[] = {3, 4, 5};
int main() {
long long x;
int i;
while (scanf("%lld", &x) != EOF) {
bool flag = false;
if (x == 1 || x == 2) {
printf("-1\n");
continue;
}
for (i = 0; i < 3; i++) {
if (x % vis[i] == 0) {
long long n = x / vis[i];
if (i == 0) {
printf("%lld %lld\n", 4 * n, 5 * n);
flag = true;
break;
} else if (i == 1) {
printf("%lld %lld\n", 3 * n, 5 * n);
flag = true;
break;
} else if (i == 2) {
printf("%lld %lld\n", 3 * n, 4 * n);
flag = true;
break;
}
}
}
if (!flag) {
if (x % 2)
printf("%lld %lld\n", x * x / 2, x * x / 2 + 1);
else {
x /= 2;
printf("%lld %lld\n", x * x / 2 * 2, (x * x / 2 + 1) * 2);
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, total;
struct aa {
int id, w;
bool operator<(const aa &b) const { return w < b.w; }
} a[15];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].w);
total += a[i].w;
a[i].id = i;
}
if (n == 2 && a[1].w == a[2].w) {
printf("-1");
return 0;
}
if (n == 1) {
printf("-1");
return 0;
}
sort(a + 1, a + 1 + n);
printf("%d\n", n - 1);
for (int i = 2; i <= n; i++) printf("%d ", a[i].id);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int A[100011];
int filled = 0;
void go(int i, int p) {
if (A[i] == -1) filled++;
A[i] = p;
cout << i + 1 << "\n";
fflush(stdout);
}
int main() {
int n, m, c, p;
cin >> n >> m >> c;
for (int i = 0; i < n + 1; i++) {
A[i] = -1;
}
while (m--) {
cin >> p;
if (p <= (c + 1) / 2) {
for (int i = 0; i < n; i++) {
if (A[i] == -1 || A[i] > p) {
go(i, p);
break;
}
}
} else {
for (int i = n - 1; i >= 0; i--) {
if (A[i] == -1 || A[i] < p) {
go(i, p);
break;
}
}
}
if (filled == n) break;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, t, r, mmax = 0;
cin >> n >> k;
int v[n];
for (int &i : v) {
cin >> i;
}
map<int, pair<int, int> > m;
for (int i = 0; i < k; i++) {
cin >> t >> r;
m[r] = make_pair(i, t);
mmax = max(mmax, r);
}
vector<int> temp(mmax);
for (int i = 0; i < mmax; i++) {
temp[i] = v[i];
}
sort(temp.begin(), temp.end());
int l = 0, order = 1, curr = -1;
r = mmax;
mmax--;
for (map<int, pair<int, int> >::reverse_iterator it = m.rbegin();
it != m.rend(); it++) {
if (curr < it->second.first) {
int aux = it->first;
while (aux < r) {
r--;
if (order == 1) {
v[r] = temp[mmax--];
} else {
v[r] = temp[l++];
}
}
curr = it->second.first;
order = it->second.second;
}
}
while (r) {
r--;
if (order == 1) {
v[r] = temp[mmax--];
} else {
v[r] = temp[l++];
}
}
for (int i = 0; i < n; i++) {
cout << v[i] << ((i == n - 1) ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool o;
char chh, ss[1 << 17], *A = ss, *B = ss;
inline char gc() {
return A == B && (B = (A = ss) + fread(ss, 1, 1 << 17, stdin), A == B) ? EOF
: *A++;
}
template <typename _Tp>
inline void rd(_Tp &x);
template <typename _Tp>
inline void wr(_Tp x);
template <typename _Tp>
inline _Tp mx(_Tp x, _Tp y);
template <typename _Tp>
inline _Tp mn(_Tp x, _Tp y);
namespace boom {
int n, qy, a[50001], y, x, cnt;
int h[50001], ne[50001], f[50001];
int dep[50001], v[50001], t[50001], d[50001], l[50001], r[50001], ss1[50001],
ss2[50001];
inline void dfs(int i) {
if (a[i] > 1) {
l[i] = ++cnt;
v[cnt] = a[i], t[i] = -2147483647, d[cnt] = dep[i];
} else {
l[i] = cnt + 1;
ss1[i] = 1, ss2[i] = dep[i];
}
for (int k = h[i]; k; k = ne[k])
dep[k] = dep[i] + 1, dfs(k), ss1[i] += ss1[k], ss2[i] += ss2[k];
r[i] = cnt;
}
inline void work() {
scanf("%d%d", &n, &qy);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) {
scanf("%d", &x);
ne[i] = h[x];
h[x] = i;
}
dfs(1);
for (register int tt = 1, i, x, s1, s2; tt <= qy; ++tt) {
scanf("%d", &x);
s1 = ss1[x], s2 = ss2[x];
for (i = l[x]; i <= r[x]; ++i) {
if (t[i] <= tt) {
s1++, s2 += d[i];
t[i] = tt + v[i];
}
}
printf("%d %d\n", s2 - dep[x] * s1, s1);
}
}
} // namespace boom
int main() {
boom::work();
return 0;
}
template <typename _Tp>
inline void rd(_Tp &x) {
o = 0;
x = 0;
while (chh ^ 45 && (chh < 48 || chh > 57)) chh = gc();
if (chh == 45) o = 1, chh = gc();
while (chh > 47 && chh < 58) {
x = (x << 1) + (x << 3) + (chh ^ 48);
chh = gc();
}
if (o) x = -x;
}
template <typename _Tp>
inline void wr(_Tp x) {
if (x < 0) x = -x, putchar(45);
if (x < 10) {
putchar(x + 48);
return;
}
wr(x / 10);
putchar(x % 10 + 48);
}
template <typename _Tp>
inline _Tp mx(_Tp x, _Tp y) {
return x > y ? x : y;
}
template <typename _Tp>
inline _Tp mn(_Tp x, _Tp y) {
return x < y ? x : y;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int ninf = 0xc0c0c0c0;
int a, b, res;
int base;
char anum[10];
char bnum[10];
int al, bl;
int resbase;
char resnum[15];
int main() {
;
scanf("%d %d", &a, &b);
;
sprintf(anum, "%d", a);
al = strlen(anum);
base = 2;
for (int i = 0; i < al; i++) {
if (anum[i] - '0' >= base) base = anum[i] - '0' + 1;
}
sprintf(bnum, "%d", b);
bl = strlen(bnum);
for (int i = 0; i < bl; i++) {
if (bnum[i] - '0' >= base) base = bnum[i] - '0' + 1;
}
a = 0;
b = 0;
;
;
int p = 1;
for (int i = 0; i < al; i++) {
a += p * (anum[al - i - 1] - '0');
p *= base;
}
p = 1;
for (int i = 0; i < bl; i++) {
b += p * (bnum[bl - i - 1] - '0');
p *= base;
};
;
res = a + b;
;
resbase = 0;
int carry = 0;
p = 1;
while (res / p) p *= base;
p /= base;
while (1) {
resbase *= 10;
resbase += (res / p);
res %= p;
if (p == 1) break;
p /= base;
};
sprintf(resnum, "%d", resbase);
int ans = strlen(resnum);
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double eps = 1e-10;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
const double pi = acos(-1.0);
const int MAX_INT = (1 << 30);
const ll MAX_LL = (1LL << 62);
ll arr[100005];
int main() {
ll n, k;
cin >> n >> k;
map<ll, ll> mp;
map<ll, ll>::iterator it;
for (int i = 0; i < n; i++) {
cin >> arr[i];
mp[arr[i]]++;
}
vector<pair<ll, ll> > cnt;
for (it = mp.begin(); it != mp.end(); it++) {
cnt.push_back(make_pair(it->first, it->second));
}
sort(arr, arr + n);
ll sum1 = 0, sum2 = 0;
for (int i = 0; i < (int)cnt.size(); i++) {
if (sum1 + cnt[i].second * n < k)
sum1 += cnt[i].second * n;
else {
ll kk = k - sum1;
for (int j = 0; j < n; j++) {
if (sum2 + cnt[i].second < kk)
sum2 += cnt[i].second;
else {
cout << cnt[i].first << ' ' << arr[j] << '\n';
return 0;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int MAX = 1e5 + 10;
const long long mod = 1e9 + 7;
int main() {
int n, m, i, j, rx[3], ry[3], bx[3], by[3], gx[3], gy[3], flag[5], tag;
char mp[111][111];
while (~scanf("%d%d", &n, &m)) {
memset((rx), (0), sizeof(rx));
memset((ry), (0), sizeof(ry));
memset((bx), (0), sizeof(bx));
memset((by), (0), sizeof(by));
memset((gx), (0), sizeof(gx));
memset((gy), (0), sizeof(gy));
memset((flag), (0), sizeof(flag));
rx[0] = ry[0] = bx[0] = by[0] = gx[0] = gy[0] = INF;
for (i = 0; i < n; i++) {
scanf("%s", mp[i]);
for (j = 0; j < m; j++) {
if (mp[i][j] == 'R') {
flag[0] = 1;
rx[0] = min(rx[0], j);
ry[0] = min(ry[0], i);
rx[1] = max(rx[1], j);
ry[1] = max(ry[1], i);
} else if (mp[i][j] == 'B') {
flag[1] = 1;
bx[0] = min(bx[0], j);
by[0] = min(by[0], i);
bx[1] = max(bx[1], j);
by[1] = max(by[1], i);
} else if (mp[i][j] == 'G') {
flag[2] = 1;
gx[0] = min(gx[0], j);
gy[0] = min(gy[0], i);
gx[1] = max(gx[1], j);
gy[1] = max(gy[1], i);
}
}
}
if (flag[0] && flag[1] && flag[2]) {
if (rx[1] - rx[0] == bx[1] - bx[0] && rx[1] - rx[0] == gx[1] - gx[0]) {
if (ry[1] - ry[0] == by[1] - by[0] && ry[1] - ry[0] == gy[1] - gy[0]) {
tag = 0;
for (i = ry[0]; i <= ry[1]; i++) {
for (j = rx[0]; j <= rx[1]; j++) {
if (mp[i][j] != 'R') tag = 1;
}
}
for (i = by[0]; i <= by[1]; i++) {
for (j = bx[0]; j <= bx[1]; j++) {
if (mp[i][j] != 'B') tag = 1;
}
}
for (i = gy[0]; i <= gy[1]; i++) {
for (j = gx[0]; j <= gx[1]; j++) {
if (mp[i][j] != 'G') tag = 1;
}
}
if (!tag)
puts("YES");
else
puts("NO");
} else
puts("NO");
} else
puts("NO");
} else
puts("NO");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int head[N], nxt[N * 2], to[N * 2], cost[N * 2], dir[N * 2], ne = 0;
int f[N];
void addedge(int a, int b, int c, int d) {
nxt[ne] = head[a];
to[ne] = b;
cost[ne] = c;
dir[ne] = d;
head[a] = ne++;
}
int ans[N];
int main() {
int n, m;
scanf("%d %d", &n, &m);
memset(head, -1, sizeof head);
int a, b, c, d;
for (int i = 0; i < m; ++i) {
scanf("%d %d %d", &a, &b, &c);
addedge(a, b, c, 0);
addedge(b, a, c, 1);
f[a] += c;
f[b] += c;
}
memset(ans, -1, sizeof ans);
for (int i = 1; i <= n; ++i) f[i] /= 2;
queue<int> q;
q.push(1);
while (q.size()) {
int idx = q.front();
q.pop();
for (int i = head[idx]; ~i; i = nxt[i]) {
int id = i / 2;
if (ans[id] == -1) {
ans[id] = dir[i];
f[to[i]] -= cost[i];
if (to[i] != n && f[to[i]] == 0) q.push(to[i]);
}
}
}
for (int i = 0; i < m; ++i) {
printf("%d\n", ans[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
vector<int> v[maxn];
int main() {
int t;
cin >> t;
int n;
int m, p;
while (t--) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
v[i].clear();
}
int m, p;
for (int i = 0; i < n; i++) {
scanf("%d%d", &m, &p);
v[m].push_back(p);
}
long long sum = 0;
int have = 0, res = n;
priority_queue<int, vector<int>, greater<int>> q;
for (int i = n - 1; i >= 0; i--) {
res -= v[i].size();
for (auto p : v[i]) q.push(p);
while (have + res < i) {
sum += q.top();
q.pop();
have++;
}
}
cout << sum << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 10;
struct node {
int x, y, yy, v;
} b[N];
bool operator<(node a, node b) {
if (a.x == b.x) return a.v > b.v;
return a.x < b.x;
}
void rotate(int &x, int &y) {
int xx = x, yy = y;
x = xx - yy;
y = xx + yy;
}
int n, k, x, y, xx, yy;
int Y[N], cnt;
int ans;
int mx[4 * N], cov[4 * N];
void pushdown(int p, int l, int r) {
if (cov[p]) {
mx[p << 1] += cov[p];
cov[p << 1] += cov[p];
mx[p << 1 | 1] += cov[p];
cov[p << 1 | 1] += cov[p];
cov[p] = 0;
}
}
void update(int p, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
mx[p] += v;
cov[p] += v;
return;
}
pushdown(p, l, r);
int mid = (l + r) / 2;
if (ql <= mid) update(p << 1, l, mid, ql, qr, v);
if (qr > mid) update(p << 1 | 1, mid + 1, r, ql, qr, v);
mx[p] = max(mx[p << 1], mx[p << 1 | 1]);
}
int ask(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return mx[p];
pushdown(p, l, r);
int mid = (l + r) / 2, ans = 0;
if (ql <= mid) ans = max(ans, ask(p << 1, l, mid, ql, qr));
if (qr > mid) ans = max(ans, ask(p << 1 | 1, mid + 1, r, ql, qr));
return ans;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &x, &y);
xx = x - k;
yy = y;
rotate(xx, yy);
b[2 * i - 1] = node{xx, yy, yy + 2 * k, 1};
xx = x + k;
yy = y;
rotate(xx, yy);
b[2 * i] = node{xx, yy - 2 * k, yy, -1};
Y[++cnt] = yy - 2 * k;
Y[++cnt] = yy;
}
sort(Y + 1, Y + cnt + 1);
cnt = unique(Y + 1, Y + cnt + 1) - (Y + 1);
for (int i = 1; i <= 2 * n; ++i) {
b[i].y = lower_bound(Y + 1, Y + cnt + 1, b[i].y) - Y;
b[i].yy = lower_bound(Y + 1, Y + cnt + 1, b[i].yy) - Y;
}
sort(b + 1, b + 2 * n + 1);
for (int i = 1; i <= 2 * n; ++i) {
update(1, 1, cnt, b[i].y, b[i].yy, b[i].v);
ans = max(ans, ask(1, 1, cnt, 1, cnt));
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
vector<long long> g[N];
long long tot = 1, col[N];
void dfs(long long node, long long par) {
long long j = 1;
for (auto v : g[node]) {
if (v == par) continue;
while (j == col[par] || j == col[node]) j++;
tot = max(tot, j);
col[v] = j++;
dfs(v, node);
}
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
;
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
col[1] = 1;
dfs(1, 0);
cout << tot << "\n";
for (long long i = 1; i <= n; i++) cout << col[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, MXA = 5090006, MXQ = 1090006, K = 9;
int n, q, A[N], R[MXQ], Rs[MXQ], LP[MXA], Frst[MXA][K], Mnr[K * 2];
vector<pair<int, int> > D[N];
vector<int> Q[N];
int main() {
scanf("%d%d", &n, &q);
for (int i = 2; i < MXA; i++)
if (!LP[i])
for (int j = i; j < MXA; j += i) LP[j] = i;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
vector<int> Pr;
while (a > 1) {
if (Pr.size() && Pr.back() == LP[a])
Pr.pop_back();
else
Pr.push_back(LP[a]);
a /= LP[a];
}
A[i] = 1;
for (int p : Pr) A[i] *= p;
for (int mask = 0; mask < (1 << Pr.size()); mask++) {
a = 1;
for (int i = 0; i < Pr.size(); i++)
if (mask >> i & 1) a *= Pr[i];
D[i].push_back({a, (int)Pr.size() - __builtin_popcount(mask)});
}
}
for (int i = 1; i <= q; i++) {
int l;
scanf("%d%d", &l, &R[i]);
Q[l].push_back(i);
}
memset(Mnr, 63, sizeof(Mnr));
memset(Frst, 63, sizeof(Frst));
for (int i = n; i; i--) {
for (auto X : D[i]) {
int d = X.first;
int c = X.second;
for (int j = 0; j < K; j++) Mnr[c + j] = min(Mnr[c + j], Frst[d][j]);
Frst[d][c] = i;
}
for (int j : Q[i])
for (int h = 0; h < K * 2; h++)
if (Mnr[h] <= R[j]) {
Rs[j] = h;
break;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", Rs[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e5 + 100;
const int MAXX = 2e6 + 100;
int prime[MAXX];
int a[MAX];
int sum1[MAXX];
long long sum2[MAXX];
bool vis[MAXX];
int tot;
int n, x, y;
long long ans = 0x3f3f3f3f3f3f3f3fLL;
void input() {
scanf("%d%d%d", &n, &x, &y);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
sum1[a[i]]++;
sum2[a[i]] += a[i];
}
}
void init() {
for (int i = 1; i <= 2e6; i++) {
sum1[i] += sum1[i - 1];
sum2[i] += sum2[i - 1];
}
for (int i = 2; i <= 1e6; i++) {
if (!vis[i]) {
prime[tot++] = i;
vis[i] = true;
}
for (int j = 0; j < tot; j++) {
int temp = i * prime[j];
if (temp > 1e6) {
break;
}
vis[temp] = true;
}
}
}
void solve() {
for (int i = 0; i < tot; i++) {
long long res = 0;
int P = prime[i];
int k = min(x / y, P - 1);
for (int j = 0; j <= 1e6; j += P) {
res += 1LL * (sum1[j + P - k - 1] - sum1[j]) * x;
res += (1LL * (sum1[j + P - 1] - sum1[j + P - k - 1]) * (j + P) -
sum2[j + P - 1] + sum2[j + P - k - 1]) *
y;
}
ans = min(ans, res);
}
printf("%I64d\n", ans);
}
int main() {
input();
init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
string pat;
int lps[3 * N];
vector<int> adj[N];
string arr[N];
void computeLPSArray(int M) {
int len = 0;
lps[0] = 0;
int i = 1;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
int ans = 0;
int dp[26][3 * N];
void dfs(int cur, int t) {
if (cur != 0) {
for (int j = 0; j < arr[cur].size(); ++j) {
if (dp[arr[cur][j] - 'a'][t] != -1)
t = dp[arr[cur][j] - 'a'][t];
else {
int pos = t;
while (t && arr[cur][j] != pat[t]) t = lps[t - 1];
dp[arr[cur][j] - 'a'][pos] = t;
}
if (arr[cur][j] == pat[t]) t++;
if (t == pat.size()) ans++, t = lps[t - 1];
}
}
for (int i = 0; i < adj[cur].size(); ++i) {
int to = adj[cur][i];
dfs(to, t);
}
}
char str[3 * N];
int main() {
int n;
cin >> n;
for (int i = 1; i < n; ++i) {
int x;
scanf("%d%s", &x, str);
x--;
arr[i] = str;
adj[x].push_back(i);
}
cin >> pat;
computeLPSArray(pat.size());
memset(dp, -1, sizeof dp);
dfs(0, 0);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 20;
const long long int mod = 1e9 + 7;
const long double EPS = 1e-12;
const int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
int solve() {
long long int a, b;
cin >> a >> b;
long long int sum = a + b;
if (sum % 3) return cout << "NO\n", 0;
long long int y = (2 * a - b);
if (y % 3) return cout << "NO\n", 0;
y /= 3;
long long int x = (a - 2 * y);
if (x >= 0 && y >= 0) return cout << "YES\n", 0;
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:67108864")
using namespace std;
template <class T>
inline T abs(T a) {
return (a) > 0 ? (a) : -(a);
}
template <class T>
inline T sqr(T a) {
return (a) * (a);
}
const long double PI = 3.1415926535897932, EPS = 1E-9;
const int INF = 1000 * 1000 * 1000, NMAX = 100005;
int ans = 0, cur = 0;
int used[NMAX];
vector<pair<int, int> > g[NMAX];
bool fail = false;
int y = 0;
void dfs(int v, int prev) {
if (fail) return;
++cur;
used[v] = y;
for (int i = 0; i < int((g[v]).size()); ++i) {
if (fail) return;
int to = g[v][i].first;
if (to == prev) continue;
int t = g[v][i].second;
if (t == 1) {
if (used[to] == 0) dfs(to, v);
} else {
if (used[to] == y) fail = true;
}
}
}
int main() {
for (int i = 0; i < int(NMAX); ++i) used[i] = 0;
int n, k, m;
scanf("%d%d", &n, &k);
for (int i = 0; i < int(k); ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
g[u].push_back(make_pair(v, 1));
g[v].push_back(make_pair(u, 1));
}
scanf("%d", &m);
for (int i = 0; i < int(m); ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u, --v;
g[u].push_back(make_pair(v, 2));
g[v].push_back(make_pair(u, 2));
}
for (int i = 0; i < int(n); ++i)
if (used[i] == 0) {
++y;
fail = false;
cur = 0;
dfs(i, i);
if (!fail) ans = max(ans, cur);
}
printf("%d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, cnt = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
if (x / i <= n && x % i == 0) cnt++;
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void adskiy_razgon() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int mxN = 1e+9 + 7;
const long long INF = 1e+18 + 7;
long long nod(long long a, long long b) {
if (b > a) {
swap(a, b);
}
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
long long nok(long long a, long long b) { return a * b / nod(a, b); }
void sp(long long a, double b) { cout << fixed << setprecision(a) << b; }
long long binpow(long long a, long long n) {
if (n == 0) {
return 1;
}
if (n % 2 == 1) {
return binpow(a, n - 1) * a;
} else {
long long b = binpow(a, n / 2);
return b * b;
}
}
string s[1000000];
int a[1000000];
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
int ans = 0;
for (int i = 0; i < m; ++i) {
cin >> a[i];
map<char, int> m;
int cnt = 0;
for (int j = 0; j < n; ++j) {
m[s[j][i]]++;
cnt = max(cnt, m[s[j][i]]);
}
ans += cnt * a[i];
}
cout << ans;
}
int main() {
adskiy_razgon();
long long t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MaxM = 1e17;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void SieveOfEratosthenes(vector<long long> &v, long long 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]) {
v.push_back(p);
}
}
bool isPowerOfTwo(int x) { return x && (!(x & (x - 1))); }
long long binpow2(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) {
return a.second < b.second;
}
return a.first < b.first;
}
void solve() {
int n;
cin >> n;
int a[n], b[n + 1];
bool c[n];
int cnt = 0;
for (int i = 0; i < n; i++) {
c[i] = true;
cin >> a[i];
b[a[i]] = i;
}
int x;
for (int i = 0; i < n; i++) {
cin >> x;
cnt = 0;
for (int j = b[x]; j >= 0; j--) {
if (c[j] == false) {
break;
}
c[j] = false;
cnt++;
}
cout << cnt << " ";
}
cout << endl;
}
int main() {
fast();
int t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[55][55];
pair<int, int> q[100010];
bool vis[55][55];
int mx[5] = {0, 0, 0, 1, -1}, my[5] = {0, 1, -1, 0, 0};
int main() {
int n, m, sum = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++)
if (s[i][j] == '#') sum++;
}
if (sum <= 2) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '#') {
memset(vis, true, sizeof(vis));
for (int i0 = 1; i0 <= n; i0++)
for (int j0 = 1; j0 <= m; j0++)
if (s[i0][j0] == '#') vis[i0][j0] = false;
vis[i][j] = true;
int he = 0, ta = 0, cnt = 1;
for (int i0 = 1; i0 <= 4; i0++)
if (!vis[i + mx[i0]][j + my[i0]]) {
vis[i + mx[i0]][j + my[i0]] = true,
q[++ta] = make_pair(i + mx[i0], j + my[i0]);
break;
}
while (he != ta) {
pair<int, int> x = q[++he];
cnt++;
for (int i0 = 1; i0 <= 4; i0++)
if (!vis[x.first + mx[i0]][x.second + my[i0]])
vis[x.first + mx[i0]][x.second + my[i0]] = true,
q[++ta] =
make_pair(x.first + mx[i0],
x.second + my[i0]);
}
if (cnt != sum) {
printf("1\n");
return 0;
}
}
printf("2\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int count = 0;
long long xLimit = 0, yLimit = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
cin >> count;
while (count--) {
cin >> xLimit >> yLimit >> x1 >> y1 >> x2 >> y2;
if (x1 < x2) {
long long temp = x1;
x1 = x2;
x2 = temp;
}
if (y1 < y2) {
long long temp = y1;
y1 = y2;
y2 = temp;
}
long long height = yLimit - y1 + y2;
long long width = xLimit - x1 + x2;
long long area = height * width * 2;
long long xOverlap = 0, yOverlap = 0;
if (2 * height > yLimit && 2 * width > xLimit) {
yOverlap = 2 * height - yLimit;
xOverlap = 2 * width - xLimit;
}
area -= xOverlap * yOverlap;
cout << xLimit * yLimit - area;
if (count != 0) cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string a, b;
cin >> a >> b;
string str = a;
sort(str.begin(), str.end());
int i = 0, j = 0, idx = -1;
while (i < a.size() && j < a.size()) {
if (a[i] == str[j])
i++, j++;
else {
idx = i;
break;
}
}
if (idx == -1) {
if (a < b)
cout << a << endl;
else
cout << "---" << endl;
} else {
for (int i = a.size() - 1; i > idx; i--) {
if (a[i] == str[idx]) {
swap(a[i], a[idx]);
break;
}
}
if (a < b)
cout << a << endl;
else
cout << "---" << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using li = long long;
using ld = long double;
using pii = pair<int, int>;
const int INF = 1e9 + 13;
const int N = 2e5 + 13;
const int M = 1e9 + 7;
int main() {
string second;
cin >> second;
string t;
cin >> t;
int n = second.size();
int m = t.size();
map<char, vector<int>> mp;
for (int i = 0; i < m; i++) {
mp[t[i]].push_back(i);
}
vector<int> pr(n + 1, 0);
for (int i = 1; i <= n; i++) {
pr[i] = pr[i - 1] + (pr[i - 1] < t.size() && t[pr[i - 1]] == second[i - 1]);
}
vector<int> suf(n + 1, 0);
suf[n] = 0;
for (int i = n - 1; i >= 0; i--) {
suf[i] = suf[i + 1] +
(suf[i + 1] < t.size() && t[m - suf[i + 1] - 1] == second[i]);
}
for (int i = 0; i < n; i++)
if (!mp[second[i]].empty()) {
int x = pr[i];
int y = suf[i + 1];
int j =
int(upper_bound(mp[second[i]].begin(), mp[second[i]].end(), pr[i]) -
mp[second[i]].begin()) -
1;
j = mp[second[i]][j];
x = min(x, j);
y = min(y, m - j - 1);
if (x + y + 1 < m) {
cout << "No" << endl;
return 0;
}
} else {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const int fxx[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
vector<int> t, ps;
void push(int v) {
t[v * 2] += ps[v];
ps[v * 2] += ps[v];
t[v * 2 + 1] += ps[v];
ps[v * 2 + 1] += ps[v];
ps[v] = 0;
}
void upd(int v, int tl, int tr, int l, int r, int val) {
if (l > r) return;
if (l == tl && r == tr) {
t[v] += val;
ps[v] += val;
} else {
push(v);
int tm = (tl + tr) / 2;
upd(v * 2, tl, tm, l, min(r, tm), val);
upd(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r, val);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
}
int get() { return t[1]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<tuple<int, int, int>> a;
for (int i = int(0); i < int(n); i++) {
int l, r, w;
cin >> l >> r >> w;
--l, r -= 2;
a.emplace_back(w, l, r);
}
--m;
sort((a).begin(), (a).end(),
[](tuple<int, int, int>& x, tuple<int, int, int>& y) {
return get<0>(x) < get<0>(y);
});
t.resize(4 * m), ps.resize(4 * m);
--m;
int ans = inf;
int j = 0;
for (int i = int(0); i < int(n); i++) {
while (j < n && get() == 0) {
upd(1, 0, m, get<1>(a[j]), get<2>(a[j]), 1);
++j;
}
if (get() == 0) break;
ans = min(ans, get<0>(a[j - 1]) - get<0>(a[i]));
upd(1, 0, m, get<1>(a[i]), get<2>(a[i]), -1);
}
cout << ans << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, S1, S2, x, P = 1e9 + 7;
long long ans, f[1000010];
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
int main() {
read(n);
int S1 = 0, S2;
for (int i = 1; i <= n; i++) read(x), S1 += (x == 1);
S2 = n - S1;
f[0] = 1;
f[1] = 1;
f[2] = 2;
for (int i = 3; i <= S1; i++) f[i] = (f[i - 1] + f[i - 2] * (i - 1) % P) % P;
ans = f[S1];
for (int i = S1 + 1; i <= n; i++) ans = ans * i % P;
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
void party(int n, vector<int> rating) {
vector<vector<int> > position(101);
set<int> s;
for (int i = 0; i < n; ++i) {
position[rating[i]].push_back(i);
s.insert(rating[i]);
}
int ans = 0;
vector<vector<bool> > result;
while (true) {
if (s.size() == 1) {
break;
}
vector<bool> game(n);
set<int>::reverse_iterator it = s.rbegin();
if (position[*it].size() == 1) {
int firstMax = *it;
s.erase(firstMax);
set<int>::reverse_iterator it2 = s.rbegin();
int secondMax = *it2;
game[position[firstMax][0]] = true;
game[position[secondMax][0]] = true;
ans++;
result.push_back(game);
if (firstMax != 0) {
s.insert(firstMax - 1);
position[firstMax - 1].push_back(position[firstMax][0]);
;
position[firstMax].erase(position[firstMax].begin());
}
if (secondMax != 0) {
s.insert(secondMax - 1);
position[secondMax - 1].push_back(position[secondMax][0]);
;
position[secondMax].erase(position[secondMax].begin());
}
if (position[secondMax].size() == 0) {
s.erase(secondMax);
}
} else if (position[*it].size() == 3) {
int firstMax = *it;
s.erase(firstMax);
s.insert(firstMax - 1);
position[firstMax - 1].push_back(position[firstMax][0]);
position[firstMax - 1].push_back(position[firstMax][1]);
position[firstMax - 1].push_back(position[firstMax][2]);
game[position[firstMax][0]] = true;
game[position[firstMax][1]] = true;
game[position[firstMax][2]] = true;
result.push_back(game);
ans++;
position[firstMax].erase(position[firstMax].begin(),
position[firstMax].begin() + 3);
} else {
int firstMax = *it;
if (position[firstMax].size() == 2) {
s.erase(firstMax);
}
s.insert(firstMax - 1);
position[firstMax - 1].push_back(position[firstMax][0]);
position[firstMax - 1].push_back(position[firstMax][1]);
game[position[firstMax][0]] = true;
game[position[firstMax][1]] = true;
result.push_back(game);
ans++;
position[firstMax].erase(position[firstMax].begin(),
position[firstMax].begin() + 2);
}
}
cout << *s.begin() << endl;
cout << ans << endl;
for (int i = 0; i < result.size(); ++i) {
for (int j = 0; j < n; ++j) {
cout << result[i][j];
}
cout << endl;
}
}
private:
};
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
Solution s;
s.party(n, v);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int temp;
while (b > 0) {
temp = b;
b = a % b;
a = temp;
}
return a;
}
int main() {
int t, i;
scanf("%d", &t);
;
string str;
while (t--) {
int ans = 0;
int f[6];
memset(f, 0, sizeof(f));
cin >> str;
for (i = 0; i < 12; i++) {
if (str[i] == 'X') {
f[0] = 1;
ans++;
break;
}
}
for (i = 0; i < 6; i++) {
if (str[i] == 'X' && str[i + 6] == 'X') {
f[1] = 1;
ans++;
break;
}
}
for (i = 0; i < 4; i++) {
if (str[i] == 'X' && str[i + 4] == 'X' && str[i + 8] == 'X') {
f[2] = 1;
ans++;
break;
}
}
for (i = 0; i < 3; i++) {
if (str[i] == 'X' && str[i + 3] == 'X' && str[i + 6] == 'X' &&
str[i + 9] == 'X') {
f[3] = 1;
ans++;
break;
}
}
for (i = 0; i < 2; i++) {
if (str[i] == 'X' && str[i + 2] == 'X' && str[i + 4] == 'X' &&
str[i + 6] == 'X' && str[i + 8] == 'X' && str[i + 10] == 'X') {
f[4] = 1;
ans++;
break;
}
}
int cnt = 0;
for (i = 0; i < 12; i++)
if (str[i] == 'X') cnt++;
if (cnt == 12) {
f[5] = 1;
ans++;
}
printf("%d ", ans);
if (f[0]) printf("1x12 ");
if (f[1]) printf("2x6 ");
if (f[2]) printf("3x4 ");
if (f[3]) printf("4x3 ");
if (f[4]) printf("6x2 ");
if (f[5]) printf("12x1 ");
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int par[N], sz[N];
int n, m;
int s, t, ds, dt;
int root(int x) {
while (x != par[x]) {
par[x] = par[par[x]];
x = par[x];
}
return x;
}
void onion(int x, int y) {
if (x == y) return;
if (sz[x] < sz[y]) {
par[x] = y;
sz[y] += sz[x];
} else {
par[y] = x;
sz[x] += sz[y];
}
}
vector<pair<int, int> > adjs[N], adjt[N];
bool vstd[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
vector<pair<int, int> > e, sol, se, te, ste, reg;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
e.push_back({x, y});
}
cin >> s >> t >> ds >> dt;
for (int i = 0; i < m; i++) {
int x = e[i].first, y = e[i].second;
if ((x == s && y == t) || (x == t && y == s)) {
ste.push_back({x, y});
continue;
}
if (x == s || y == s) {
se.push_back({x, y});
continue;
}
if (x == t || y == t) {
te.push_back({x, y});
continue;
}
reg.push_back({x, y});
}
for (int i = 0; i < (int)reg.size(); i++) {
int x = reg[i].first, y = reg[i].second;
x = root(x);
y = root(y);
if (x == y) continue;
sol.push_back({reg[i].first, reg[i].second});
onion(x, y);
}
for (int i = 0; i < (int)se.size(); i++) {
int x = se[i].first, y = se[i].second;
x = root(x);
y = root(y);
if (x == s) {
adjs[y].push_back(se[i]);
} else {
adjs[x].push_back(se[i]);
}
}
for (int i = 0; i < (int)te.size(); i++) {
int x = te[i].first, y = te[i].second;
x = root(x);
y = root(y);
if (x == t) {
adjt[y].push_back(te[i]);
} else {
adjt[x].push_back(te[i]);
}
}
vector<int> roots;
for (int i = 1; i <= n; i++) {
int x = root(i);
if (vstd[x]) continue;
vstd[x] = true;
if (!adjs[x].empty() && !adjt[x].empty()) {
roots.push_back(x);
continue;
}
if (!adjs[x].empty()) {
sol.push_back(adjs[x][0]);
onion(root(adjs[x][0].first), root(adjs[x][0].second));
ds--;
}
if (!adjt[x].empty()) {
sol.push_back(adjt[x][0]);
onion(root(adjt[x][0].first), root(adjt[x][0].second));
dt--;
}
}
if (!roots.empty()) {
ds--;
dt--;
sol.push_back(adjs[roots.back()][0]);
onion(root(adjs[roots.back()][0].first),
root(adjs[roots.back()][0].second));
sol.push_back(adjt[roots.back()][0]);
onion(root(adjt[roots.back()][0].first),
root(adjt[roots.back()][0].second));
roots.pop_back();
} else {
if (!ste.empty()) {
ds--;
dt--;
sol.push_back(ste[0]);
onion(root(ste[0].first), root(ste[0].second));
}
}
while (sz[root(1)] != n && !roots.empty() && ds > 0) {
ds--;
sol.push_back(adjs[roots.back()][0]);
onion(root(adjs[roots.back()][0].first),
root(adjs[roots.back()][0].second));
roots.pop_back();
}
while (sz[root(1)] != n && !roots.empty() && dt > 0) {
dt--;
sol.push_back(adjt[roots.back()][0]);
onion(root(adjt[roots.back()][0].first),
root(adjt[roots.back()][0].second));
roots.pop_back();
}
if (ds < 0 || dt < 0 || sz[root(1)] != n) {
cout << "No";
return 0;
}
cout << "Yes\n";
for (int i = 0; i < (int)sol.size(); i++) {
cout << sol[i].first << " " << sol[i].second << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ans = 0;
int a, p, oldp;
scanf("%d %d", &a, &p);
ans = a * p;
oldp = p;
for (int i = 1; i < n; i++) {
scanf("%d %d", &a, &p);
p = min(p, oldp);
ans += a * p;
oldp = p;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k = 0;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
long long r = 0;
if (a[lower_bound(a, a + n, a[i] * 3) - a] != a[i] * 3) r++;
if (a[i] % 2 == 1) {
r++;
}
if (a[i] % 2 == 0) {
if (a[lower_bound(a, a + n, a[i] / 2) - a] != a[i] / 2) r++;
}
if (r == 2) {
k = a[i];
break;
}
}
cout << k << ' ';
for (int i = 1; i < n; i++) {
if (a[lower_bound(a, a + n, k / 3) - a] == k / 3 && k % 3 == 0) {
cout << k / 3 << ' ';
k /= 3;
continue;
}
if (a[lower_bound(a, a + n, k * 2) - a] == k * 2) {
cout << k * 2 << ' ';
k *= 2;
continue;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
vector<int> ans;
int n;
void add(int x, int y) {
ans.push_back(x);
ans.push_back(y);
ans.push_back(x);
ans.push_back(y);
}
void solve(int &i) {
map<int, int> between, left, cnt;
stack<int> st;
for (int x; i <= n; ++i) {
scanf("%d", &x);
if (between[x]) {
add(between[x], x);
return;
}
if (++cnt[x] == 4) {
add(x, x);
return;
}
if (left[x]) {
while (st.size()) {
int y = st.top();
st.pop();
if (y == x) break;
between[y] = x;
}
}
left[x] = i;
st.push(x);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) solve(i);
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) printf("%d ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int x, y;
cin >> x >> y;
if (x == y) {
cout << "0"
<< "\n";
} else if (x < y) {
long long int z = y - x;
long long int d = z / 10;
if (z % 10) {
cout << d + 1 << "\n";
} else {
cout << d << "\n";
}
} else {
long long int z = abs(x - y);
long long int d = z / 10;
if (z % 10) {
cout << d + 1 << "\n";
} else {
cout << d << "\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
int mxEXP = INF;
int mxLIKE = 0;
int team[10];
int like[10][10];
int EXP[10];
int cnt[5];
int solve() {
memset(cnt, 0, sizeof(cnt));
;
for (int(i) = 1, j123 = 7; (i) <= j123; (i)++) cnt[team[i]]++;
for (int(i) = 1, j123 = 3; (i) <= j123; (i)++)
if (cnt[i] == 0) return 0;
vector<int> v;
for (int(i) = 1, j123 = 3; (i) <= j123; (i)++) v.push_back(EXP[i] / cnt[i]);
sort(v.begin(), v.end());
int diff = v[2] - v[0];
if (diff > mxEXP) return 0;
int cntlike = 0;
for (int(i) = 1, j123 = 7; (i) <= j123; (i)++)
for (int(j) = 1, j123 = 7; (j) <= j123; (j)++)
if (i != j)
if (team[i] == team[j])
if (like[i][j]) cntlike++;
if (mxEXP > diff) {
mxEXP = diff;
mxLIKE = cntlike;
} else if (mxEXP == diff) {
mxLIKE = max(mxLIKE, cntlike);
}
return 0;
}
int dfs(int index) {
if (index == 8) {
solve();
} else {
for (int i = 1; i <= 3; i++) {
team[index] = i;
dfs(index + 1);
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
int N;
cin >> N;
map<string, int> dict;
int n = 0;
for (int(i) = 1, j123 = N; (i) <= j123; (i)++) {
string a, foo, b;
cin >> a >> foo >> b;
if (dict[a] == 0) {
n++;
dict[a] = n;
}
if (dict[b] == 0) {
n++;
dict[b] = n;
}
like[dict[a]][dict[b]] = 1;
}
for (int(i) = 1, j123 = 3; (i) <= j123; (i)++) cin >> EXP[i];
dfs(1);
cout << mxEXP << " " << mxLIKE << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T t) {
return t < 0 ? -t : t;
}
const int modn = 1000000007;
inline int mod(int x) { return x % modn; }
char g[500][500];
int n, m;
inline bool inside(int i3, int j3, int i1, int j1, int i2, int j2) {
return i3 >= i1 && i3 <= i2 && j3 >= j1 && j3 <= j2;
}
int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int memo[2][500][500];
int main() {
int i, j, i2;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) scanf(" %c", &g[i][j]);
for (i = n - 1; i >= 0; i--)
for (j = m - 1; j >= 0; j--)
for (i2 = i; i2 < n; i2++) {
int j2 = (m + n - 2 - i - j - i2);
int &r = memo[i % 2][j][i2];
r = 0;
if (i > i2 || j > j2) {
r = 0;
continue;
}
if (g[i][j] != g[i2][j2]) {
r = 0;
continue;
}
if (i == i2 && j == j2) {
r = 1;
continue;
}
if (i == i2 && abs(j - j2) == 1) {
r = g[i][j] == g[i2][j2];
continue;
}
if (j == j2 && abs(i - i2) == 1) {
r = g[i][j] == g[i2][j2];
continue;
}
for (int d1 = 0; d1 <= 1; d1++)
for (int d2 = 2; d2 <= 3; d2++) {
int ni = i + dir[d1][0], nj = j + dir[d1][1];
int ni2 = i2 + dir[d2][0], nj2 = j2 + dir[d2][1];
if (!inside(ni, nj, i, j, i2, j2) ||
!inside(ni2, nj2, i, j, i2, j2))
continue;
r = mod(r + memo[ni % 2][nj][ni2]);
}
}
printf("%d\n", memo[0][0][n - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int INF_INT = 0x3f3f3f3f;
const long long INF_LL = 0x7f7f7f7f;
const int MOD = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1);
using namespace std;
const int N = 200200;
int n, m, q;
int u[N], v[N];
struct Query {
int l, r, s, t, id;
Query(int l, int r, int s, int t, int id) : l(l), r(r), s(s), t(t), id(id) {}
Query() {}
bool operator<(const Query& rhs) const { return l > rhs.l; }
};
vector<Query> qs;
int dp[1010][1010];
int ans[N];
int main(int argc, char const* argv[]) {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; i++) scanf("%d%d", &u[i], &v[i]);
for (int i = 1; i <= q; i++) {
int l, r, s, t;
scanf("%d%d", &l, &r);
scanf("%d%d", &s, &t);
qs.emplace_back(l, r, s, t, i);
}
sort(qs.begin(), qs.end());
memset((dp), (INF_INT), sizeof(dp));
for (int i = 1; i <= n; i++) dp[i][i] = 0;
int cnt = 0;
for (int i = m; i >= 1; i--) {
dp[u[i]][v[i]] = dp[v[i]][u[i]] = i;
for (int j = 1; j <= n; j++) {
if (j != u[i]) dp[v[i]][j] = min(dp[v[i]][j], dp[u[i]][j]);
if (j != v[i]) dp[u[i]][j] = min(dp[u[i]][j], dp[v[i]][j]);
}
while (cnt < qs.size() && qs[cnt].l >= i) {
ans[qs[cnt].id] = dp[qs[cnt].s][qs[cnt].t] <= qs[cnt].r;
cnt++;
}
}
for (int i = 1; i <= q; i++) puts(ans[i] ? "Yes" : "No");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int maxn = 2e6 + 100;
char s[maxn];
int ans[20][20], a[maxn];
int g[20][20][20], cnt[20], dig[20][20], vis[10][10];
void solve() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; (i) <= (n - 1); i++) {
a[i] = ((s[i + 1] - '0') - (s[i] - '0') + 10) % 10;
}
for (int i = 0; (i) < (10); i++) {
int now = i;
while (now) {
dig[i][++cnt[i]] = now;
now = now + i;
now %= 10;
}
dig[i][++cnt[i]] = now;
}
dig[0][1] = 0;
cnt[0] = 1;
memset(g, -1, sizeof(g));
for (int i = 0; (i) < (10); i++)
for (int j = 0; (j) < (10); j++)
for (int k = 0; (k) < (10); k++) {
int res = inf, mark = 0, flag = 0;
for (int u = 1; (u) <= (cnt[i]); u++) {
mark++;
if (dig[i][u] == k) {
flag = 1;
break;
}
}
if (flag) res = min(res, mark);
mark = 0, flag = 0;
for (int u = 1; (u) <= (cnt[j]); u++) {
mark++;
if (dig[j][u] == k) {
flag = 1;
break;
}
}
if (flag) res = min(res, mark);
for (int ui = 1; (ui) <= (cnt[i]); ui++) {
mark = ui, flag = 0;
for (int uj = 1; (uj) <= (cnt[j]); uj++) {
mark++;
if ((dig[j][uj] + dig[i][ui]) % 10 == k) {
flag = 1;
break;
}
}
if (flag) res = min(res, mark);
}
for (int uj = 1; (uj) <= (cnt[j]); uj++) {
mark = uj, flag = 0;
for (int ui = 1; (ui) <= (cnt[i]); ui++) {
mark++;
if ((dig[j][uj] + dig[i][ui]) % 10 == k) {
flag = 1;
break;
}
}
if (flag) res = min(res, mark);
}
g[i][j][k] = g[j][i][k] = (res == inf) ? -1 : res;
}
for (int i = 0; (i) < (10); i++)
for (int j = 0; (j) < (10); j++)
for (int k = 1; (k) <= (n - 1); k++) {
if (~g[i][j][a[k]] && !vis[i][j])
ans[i][j] += g[i][j][a[k]];
else
ans[i][j] = -1, vis[i][j] = 1;
}
for (int i = 0; (i) < (10); i++) {
for (int j = 0; (j) < (10); j++) {
if (~ans[i][j])
printf("%d ", ans[i][j] - n + 1);
else
printf("%d ", ans[i][j]);
}
printf("\n");
}
}
int main() {
solve();
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MAXN = 1000000;
int n, N, TO[128], seq[2 * MAXN + 5], Z[2 * MAXN + 5];
char s1[MAXN + 5], s2[MAXN + 5];
void getZ() {
int F = -1, R = -1;
Z[0] = N;
for (int k = 1; k < N; k++) {
if (R <= k) {
for (Z[k] = 0; k + Z[k] < N && seq[Z[k]] == seq[k + Z[k]]; Z[k]++)
;
if (k + Z[k] >= R) {
R = k + Z[k];
F = k;
}
} else {
Z[k] = min(Z[k - F], R - k);
if (k + Z[k] >= R) {
R = k + Z[k];
F = k;
for (; k + Z[k] < N && seq[Z[k]] == seq[k + Z[k]]; Z[k]++) R++;
}
}
}
}
int main() {
TO['N'] = 0;
TO['S'] = 1;
TO['E'] = 2;
TO['W'] = 3;
scanf("%d%s%s", &n, s1, s2);
n--;
N = n + n;
for (int k = 0; k < (n); k++) seq[n - k - 1] = TO[s1[k]];
for (int k = 0; k < (n); k++) seq[n + k] = TO[s2[k]] ^ 1;
getZ();
for (int k = 0; k < (n); k++)
if (Z[k + n] + k >= n) {
printf("NO");
return 0;
}
printf("YES");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int l = 0, r = 0;
int main() {
cin >> s >> t;
while (s[l] != '|') l++;
r = s.size() - l - 1;
int dif;
if (l > r)
dif = t.size() - (l - r);
else
dif = t.size() - (r - l);
if (dif < 0 || dif & 1) {
cout << "Impossible" << endl;
return 0;
}
if (l < r) {
reverse(s.begin(), s.end());
int i = 0;
while (l < r) {
s += t[i];
i++;
l++;
}
while (i < t.size()) {
s += t[i];
i++;
s = t[i] + s;
i++;
}
reverse(s.begin(), s.end());
cout << s << endl;
return 0;
}
int i = 0;
while (r < l) {
s += t[i];
i++;
r++;
}
while (i < t.size()) {
s += t[i];
i++;
s = t[i] + s;
i++;
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void twoPerRow(int row, int rows, bool flag) {
int start = row;
for (int i = row; i < rows; i++) {
int num = i * 2;
num++;
cout << num << " " << num + 1 << " ";
}
if (flag) {
int rest = rows;
rest *= 2;
rest++;
cout << rest;
}
}
int main() {
int n, m;
cin >> n >> m;
if (m <= n * 2) {
bool flag = false;
if (m % 2 != 0) {
flag = true;
}
twoPerRow(0, m / 2, flag);
} else {
int fullRows = (m - (n * 2)) / 2;
int mid = n * 4;
mid /= 2;
int currentRow = 0;
bool flag;
while (fullRows > 0) {
int temp = currentRow * 2;
temp++;
cout << mid + temp << " " << temp << " " << mid + temp + 1 << " "
<< temp + 1 << " ";
fullRows--;
currentRow++;
}
int rest = m - (currentRow)*4;
if (rest == 0) {
return 0;
}
if (rest < 4) {
int i = m / 4;
int num = i * 2;
num++;
if (m % 4 == 1)
cout << num;
else if (m % 4 == 2)
cout << num << " " << num + 1;
else if (m % 4 == 3)
cout << mid + num << " " << num << " " << num + 1;
} else {
int remainingRows = n - currentRow;
int threeSeatedRow = rest % (2);
if (threeSeatedRow > 0) {
int t = currentRow;
t *= 2;
cout << mid + t + 1 << " " << t + 1 << " " << t + 2 << " ";
currentRow++;
remainingRows--;
}
twoPerRow(currentRow, currentRow + remainingRows, 0);
}
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.