solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long a[n], ans[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
long long j = 1;
for (long long i = 0; i < n / 2; ++i) {
ans[j] = a[i];
j += 2;
}
j = 0;
for (long long i = n / 2; i < n; ++i) {
ans[j] = a[i];
j += 2;
}
cout << (n - 1) / 2 << "\n";
for (long long i = 0; i < n; ++i) cout << ans[i] << " ";
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void faltu() {}
int32_t main() {
faltu();
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cout << (char)('a' + (i % 4));
}
cout << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
int ct = 0;
for (int q = 0; q < n; q++) {
if (s[q] == '0') {
ct++;
}
if (t[q] == '0') {
ct--;
}
}
if (ct != 0) {
cout << "-1\n";
return 0;
}
vector<int> diff;
for (int q = 0; q < n; q++) {
if (s[q] != t[q]) {
diff.push_back(s[q] - '0');
}
}
int sz = diff.size();
if (sz == 0) {
cout << "0\n";
return 0;
}
int cur = diff[0];
int ct1 = 1;
vector<int> distinct;
for (int q = 1; q < sz; q++) {
if (diff[q] == cur) {
ct1++;
} else {
distinct.push_back(ct1);
ct1 = 1;
cur = diff[q];
}
}
distinct.push_back(ct1);
int ans = INT_MIN;
int tot = 0;
int dsz = distinct.size();
set<int> pref;
pref.insert(0);
for (int q = 0; q < distinct.size(); q++) {
if (q % 2 == 0) {
tot += distinct[q];
} else {
tot -= distinct[q];
}
if (tot < 0) {
ans = max(ans, abs(tot - *pref.rbegin()));
} else {
ans = max(ans, tot - *pref.begin());
}
pref.insert(tot);
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-10;
const long long MOD = 1000000007ll;
const long long mod1 = 1000000009ll;
const long long mod2 = 1100000009ll;
int INF = (int)1e9 + 5;
long long INFINF = (long long)1e18;
int n;
string sizes[] = {"S", "M", "L", "XL", "XXL", "XXXL",
"S,M", "M,L", "L,XL", "XL,XXL", "XXL,XXXL"};
int size_avail[6];
pair<int, int> req[100010];
int ans[100010];
int main() {
for (int i = 0; i < 6; i++) scanf("%d", &size_avail[i]);
scanf("%d", &n);
string x;
for (int i = 1; i <= n; i++) {
cin >> x;
for (int j = 0; j < 11; j++)
if (sizes[j] == x) {
req[i] = make_pair(j, i);
break;
}
}
sort(req + 1, req + n + 1);
for (int i = 1; i <= n; i++) {
int t_shirt = req[i].first;
int pos = req[i].second;
if (t_shirt < 6) {
if (size_avail[t_shirt] > 0) {
size_avail[t_shirt]--;
ans[pos] = t_shirt;
} else {
cout << "NO" << endl;
return 0;
}
} else {
t_shirt -= 6;
if (size_avail[t_shirt] > 0) {
size_avail[t_shirt]--;
ans[pos] = t_shirt;
} else {
t_shirt++;
if (size_avail[t_shirt] > 0) {
size_avail[t_shirt]--;
ans[pos] = t_shirt;
} else {
cout << "NO" << endl;
return 0;
}
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) cout << sizes[ans[i]] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 100010;
int N, M;
int A[MAXN], B[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> N >> M;
int ma = 0, secMa = 0;
ll ans = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
if (a > ma) {
secMa = ma;
ma = a;
} else if (a > secMa) {
secMa = a;
}
ans += ll(M) * a;
}
int cnt = 0;
for (int i = 0; i < M; i++) {
int b;
cin >> b;
if (b < ma) {
cout << -1 << endl;
return 0;
}
if (b > ma) {
if (cnt == M - 1) {
ans += b - secMa;
} else {
ans += b - ma;
cnt++;
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
int fh = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= fh;
}
int m, n, a[210][210], b[210][210];
bool pa(int x) {
for (int i = 1; i <= m; i++)
if (b[x][1] != b[x][i]) return 0;
return 1;
}
bool pa1(int x) {
int l = 1, r = m;
while (l + 1 <= m && b[x][l] == b[x][1]) l++;
while (r - 1 >= 1 && b[x][r] == b[x][m]) r--;
return (l > r);
}
bool check1() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) b[i][j] = a[i][j];
for (int i = 1; i <= m; i++)
if (b[1][i])
for (int j = 1; j <= n; j++) b[j][i] ^= 1;
int l = 1, r = n;
while (l + 1 <= n && pa(l)) l++;
while (r - 1 >= 1 && pa(r)) r--;
if (l < r) return 0;
if (l == r && !pa1(l)) return 0;
puts("YES");
for (int i = 1; i <= l; i++) printf("%d", b[i][1]);
for (int i = l + 1; i <= n; i++) printf("%d", 1 - b[i][1]);
puts("");
for (int i = 1; i <= m; i++) printf("%d", a[1][i]);
puts("");
return 1;
}
bool check2() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) b[i][j] = a[i][j];
for (int i = 1; i <= m; i++)
if (!b[n][i])
for (int j = 1; j <= n; j++) b[j][i] ^= 1;
int l = 1, r = n;
while (l + 1 <= n && pa(l)) l++;
while (r - 1 >= 1 && pa(r)) r--;
if (l < r) return 0;
if (l == r && !pa1(l)) return 0;
puts("YES");
for (int i = 1; i <= l; i++) printf("%d", b[i][1]);
for (int i = l + 1; i <= n; i++) printf("%d", 1 - b[i][1]);
puts("");
for (int i = 1; i <= m; i++) printf("%d", 1 - a[n][i]);
puts("");
return 1;
}
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) read(a[i][j]);
if (n == 1) {
puts("YES");
puts("1");
for (int j = 1; j <= m; j++) printf("%d", a[1][j]);
puts("");
} else {
if (check1()) return 0;
if (check2()) return 0;
puts("NO");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int add(int _a, int _b) {
if (_a < 0) {
_a += 1000000007;
}
if (_b < 0) {
_b += 1000000007;
}
if (_a + _b >= 1000000007) {
return _a + _b - 1000000007;
}
return _a + _b;
}
inline int mul(int _a, int _b) {
if (_a < 0) {
_a += 1000000007;
}
if (_b < 0) {
_b += 1000000007;
}
return ((long long int)((long long int)_a * (long long int)_b)) % 1000000007;
}
const int N = 1000000;
long long int tree[4 * N + 10], lz[4 * N + 10], cost[N + 10], dp[N + 10];
int n, parent[N + 10], m, sbtr[N + 10];
char w[N + 10];
vector<int> adj[N + 10], vec;
bool mark[N + 10];
void input() {
int i, j;
scanf("%d", &n);
++n;
for (i = 0; i < n - 1; ++i) {
scanf("%d %c", &parent[i + 1], &w[i + 1]);
adj[parent[i + 1]].push_back(i + 1);
}
scanf("%d", &m);
for (i = 0; i < m; ++i) {
int x;
scanf("%d", &x);
mark[x] = true;
vec.push_back(x);
}
}
bool cmp(int lhs, int rhs) { return w[lhs] < w[rhs]; }
void dfs(int src) {
int i, j;
sbtr[src] += mark[src];
long long int sum = 0;
for (i = 0; i < adj[src].size(); ++i) {
int u = adj[src][i];
dfs(u);
cost[u] = sum;
sbtr[src] += sbtr[u];
sum += sbtr[u];
}
}
void make_tree(int lo, int hi, int iter) {
int mid = (lo + hi) >> 1;
if (lo == hi) {
tree[iter] = 100000000000, lz[iter] = 0;
return;
} else if (lo < hi) {
tree[iter] = 100000000000, lz[iter] = 0;
make_tree(lo, mid, 2 * iter + 1);
make_tree(mid + 1, hi, 2 * iter + 2);
}
}
void mrg(int iter) { tree[iter] = min(tree[2 * iter + 1], tree[2 * iter + 2]); }
void lazy_up(int iter, long long int v) {
tree[iter] += v;
lz[iter] += v;
}
void push_down(int iter) {
lazy_up(2 * iter + 1, lz[iter]);
lazy_up(2 * iter + 2, lz[iter]);
lz[iter] = 0;
}
void point_update(int lo, int hi, int iter, int idx, long long int v) {
int mid = (lo + hi) >> 1;
if (lo == hi) {
tree[iter] = v;
return;
}
push_down(iter);
if (idx >= lo && idx <= mid) {
point_update(lo, mid, 2 * iter + 1, idx, v);
} else {
point_update(mid + 1, hi, 2 * iter + 2, idx, v);
}
mrg(iter);
}
void range_update(int lo, int hi, int iter, int l, int r, long long int v) {
int mid = (lo + hi) >> 1;
if (l > r) {
return;
}
if (l <= lo && r >= hi) {
lazy_up(iter, v);
return;
}
push_down(iter);
if (l >= lo && r <= mid) {
range_update(lo, mid, 2 * iter + 1, l, r, v);
} else if (l >= mid + 1 && r <= hi) {
range_update(mid + 1, hi, 2 * iter + 2, l, r, v);
} else {
range_update(lo, mid, 2 * iter + 2, l, mid, v);
range_update(mid + 1, hi, 2 * iter + 2, mid + 1, r, v);
}
mrg(iter);
}
void F(int src) {
int i, j;
if (src) {
point_update(0, n - 1, 0, src, dp[parent[src]]);
range_update(0, n - 1, 0, 0, n, cost[src] + mark[parent[src]]);
if (mark[src]) {
dp[src] = min(tree[0] + 1, dp[parent[src]] + 1);
} else {
dp[src] = dp[parent[src]] + 1;
}
}
for (i = 0; i < adj[src].size(); ++i) {
int u = adj[src][i];
F(u);
}
if (src) {
point_update(0, n - 1, 0, src, 100000000000);
range_update(0, n - 1, 0, 0, n, -(cost[src] + mark[parent[src]]));
}
}
void solve() {
int i, j;
for (i = 0; i < n; ++i) {
sort(adj[i].begin(), adj[i].end(), cmp);
}
dfs(0);
make_tree(0, n - 1, 0);
dp[0] = 0, F(0);
for (i = 0; i < vec.size(); ++i) {
if (i) {
printf(" ");
}
printf("%lld", dp[vec[i]]);
}
puts("");
}
int main() {
input();
solve();
}
| 9 |
#include <bits/stdc++.h>
int32_t gcd(int32_t a, int32_t b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void factorize(int32_t num, std::vector<int32_t>& candidates) {
for (int32_t i = 2; i * i <= num; i++) {
if (num % i == 0) {
candidates.push_back(i);
while (num % i == 0) num /= i;
}
}
if (num != 1) candidates.push_back(num);
}
int main() {
int32_t n, a, b;
std::cin >> n >> a >> b;
int32_t* arr = new int32_t[n];
for (int32_t i = 0; i < n; i++) std::cin >> arr[i];
int32_t gcd_ = 0;
for (int32_t i = 0; i < n; i++) gcd_ = gcd(gcd_, arr[i]);
if (gcd_ != 1) {
std::cout << 0;
return 0;
}
std::vector<int32_t> candidates;
factorize(arr[0], candidates);
factorize(arr[0] - 1, candidates);
factorize(arr[0] + 1, candidates);
factorize(arr[n - 1], candidates);
factorize(arr[n - 1] - 1, candidates);
factorize(arr[n - 1] + 1, candidates);
std::sort(candidates.begin(), candidates.end());
candidates.resize(std::unique(candidates.begin(), candidates.end()) -
candidates.begin());
int64_t answer = INT64_MAX;
int32_t* deltas = new int32_t[n];
int64_t* delta_pref_sums = new int64_t[n + 1];
for (int32_t i = 0; i < candidates.size(); i++) {
int64_t cost_cur = 0;
int32_t first_real_bad = n, last_real_bad = -1;
bool* good = new bool[n];
for (int32_t j = 0; j < n; j++) {
if (arr[j] % candidates[i] == 0)
good[j] = true;
else if ((arr[j] + 1) % candidates[i] == 0 ||
(arr[j] - 1) % candidates[i] == 0)
good[j] = false;
else {
first_real_bad = std::min(first_real_bad, j);
last_real_bad = j;
}
}
if (first_real_bad != n) {
cost_cur += a * (int64_t)(last_real_bad - first_real_bad + 1);
for (int32_t j = 0; j < first_real_bad; j++) cost_cur += good[j] ? 0 : b;
for (int32_t j = last_real_bad + 1; j < n; j++)
cost_cur += good[j] ? 0 : b;
for (int32_t j = 0; j < first_real_bad; j++)
deltas[j] = good[j] ? -a : (b - a);
for (int32_t j = first_real_bad; j <= last_real_bad; j++) deltas[j] = 0;
for (int32_t j = last_real_bad + 1; j < n; j++)
deltas[j] = good[j] ? -a : (b - a);
delta_pref_sums[0] = 0;
for (int32_t j = 1; j <= n; j++)
delta_pref_sums[j] = delta_pref_sums[j - 1] + deltas[j - 1];
int64_t economy = INT64_MIN;
int64_t min_pref = 0;
for (int32_t j = 1; j <= n; j++) {
if (j > last_real_bad)
economy = std::max(economy, delta_pref_sums[j] - min_pref);
if (j <= first_real_bad)
min_pref = std::min(min_pref, delta_pref_sums[j]);
}
cost_cur -= economy;
} else {
for (int32_t j = 0; j < n; j++) cost_cur += good[j] ? 0 : b;
int32_t new_a = std::min(b, a);
for (int32_t j = 0; j < n; j++)
deltas[j] = good[j] ? -new_a : (b - new_a);
delta_pref_sums[0] = 0;
for (int32_t j = 1; j <= n; j++)
delta_pref_sums[j] = delta_pref_sums[j - 1] + deltas[j - 1];
int64_t economy = 0;
int64_t min_pref = 0;
for (int32_t j = 1; j <= n; j++) {
economy = std::max(economy, delta_pref_sums[j] - min_pref);
min_pref = std::min(min_pref, delta_pref_sums[j]);
}
cost_cur -= economy;
}
answer = std::min(answer, cost_cur);
}
std::cout << answer;
return 0;
}
| 7 |
#include<iostream>
#include<stdio.h>
#include<cstdio>
#include<string.h>
#include<algorithm>
#include<cmath>
#include<vector>
#include <unordered_map>
#include<climits>
#include<set>
#include <iomanip>
#include<numeric>
#include<queue>
#include<stack>
using namespace std;
#define ff first
#define ss second
#define ll long long
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define pii pair<ll,ll>
#define vi vector<ll>
#define mii map<ll,ll>
#define pqb priority_queue<ll>
#define pqs priority_queue<ll,vi,greater<ll> >
#define mod 1000000007
#define inf 1e18
#define all(v) (v).begin(),(v).end()
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define FIO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define endl "\n"
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin) ;
freopen("output.txt","w",stdout) ;
#endif
FIO ;
int t ;
t =1 ;
cin >> t ;
while(t--){
ll n ;
cin >> n ;
ll arr[n] ;
ll arr1[n] ;
ll arr2[n] ;
for(int i =0 ; i < n ; i++){
cin >> arr[i] ;
arr1[i] = arr[i] ;
arr2[i] = arr[i] ;
}
arr1[0] = abs(arr[0]-arr[1]) ;
arr1[n-1] = abs(arr[n-2]- arr[n-1]) ;
for(int i =1 ; i < n-1 ; i++){
if((arr[i] > arr[i-1] && arr[i] < arr[i+1]) || (arr[i] < arr[i-1] && arr[i] > arr[i+1]) ){
arr1[i] = 0 ;
}
else{
arr1[i] = abs(arr[i] - arr[i+1]) + abs(arr[i] - arr[i-1]) - abs(arr[i+1] - arr[i-1]);
}
}
ll mx1 = 0 ;
ll i1 = 0 ;
for(int i = 0 ; i < n ;i++){
if(arr1[i] > mx1){
mx1 = arr1[i] ;
i1 = i ;
}
}
if(i1 == 0){
arr[i1] = arr[i1+1] ;
}
else{
arr[i1] = arr[i1-1] ;
}
ll ans = 0 ;
for(int i = n-1 ; i > 0 ; i--){
ans += abs(arr[i] - arr[i-1]) ;
}
cout<<ans<<endl ;
}
return 0 ;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
int N;
const double PI = acos(-1.0);
class pt2 {
public:
long long x, y;
pt2() {}
pt2(long long _x, long long _y) {
x = _x;
y = _y;
}
pt2 vec2(const pt2 &p) { return pt2(p.x - x, p.y - y); }
double len() { return sqrt(x * x + y * y); }
double dist(const pt2 &p) {
long long dx = x - p.x, dy = y - p.y;
return sqrt(dx * dx + dy * dy);
}
pair<double, double> getPDD() { return pair<double, double>(x, y); }
long long dot(const pt2 &p) { return x * p.x + y * p.y; }
long long cross(const pt2 &p) { return x * p.y - y * p.x; }
pt2 operator+(const pt2 &p) { return pt2(x + p.x, y + p.y); }
pt2 operator-(const pt2 &p) { return pt2(x - p.x, y - p.y); }
pt2 operator*(const double &t) { return pt2(x * t, y * t); }
pt2 operator/(const double &t) { return pt2(x / t, y / t); }
bool operator==(const pt2 &p) { return x == p.x && y == p.y; }
bool operator<(const pt2 &p) const { return x < p.x || y < p.y; }
} P[1005];
long long gcd(long long x, long long y) { return !y ? x : gcd(y, x % y); }
class line2 {
public:
long long a, b, c;
line2() {}
line2(long long _a, long long _b, long long _c) {
a = _a;
b = _b;
c = _c;
}
line2(const pt2 &p1, const pt2 &p2) {
a = p2.y - p1.y;
b = p1.x - p2.x;
c = p2.x * p1.y - p1.x * p2.y;
long long g = gcd(abs(a), abs(b));
long long ga = gcd(g, abs(c));
a /= ga;
b /= ga;
c /= ga;
}
bool onLine(const pt2 &p) { return p.x * a + p.y * b + c == 0; }
pair<double, double> intersect(const line2 &l) {
return pair<double, double>(
(double)(b * l.c - c * l.b) / (a * l.b - b * l.a),
(double)(a * l.c - c * l.a) / (b * l.a - a * l.b));
}
bool same(const line2 &l) {
if (!parallel(l)) return 0;
if (a != 0) return a * l.c == c * l.a;
return b * l.c == c * l.b;
}
bool parallel(const line2 &l) { return a * l.b == b * l.a; }
};
int side(pt2 o, pt2 &a, pt2 &b) {
pt2 va = o.vec2(a), vb = o.vec2(b);
long long d = va.cross(vb);
if (d == 0) return 0;
return d > 0 ? 1 : -1;
}
bool intersectLineSeg(pt2 &p1, pt2 &p2, pt2 &a, pt2 &b) {
return side(p1, p2, a) != side(p1, p2, b);
}
int M, K;
line2 lines[1005];
pair<double, pair<pair<double, double>, int> > pts[1005 * 2];
long long getValue() {
char str[15];
scanf("%s", str);
long long x = 0;
int neg = 1, needFloat = -1;
for (int i = (0); i < (strlen(str)); i++) {
if (str[i] == '-')
neg = -1;
else if (str[i] == '.')
needFloat = 2;
else {
if (needFloat > 0) needFloat--;
x = x * 10 + (str[i] - '0');
}
}
if (needFloat == -1) return neg * x * 100;
while (needFloat--) x *= 10;
return x * neg;
}
int main() {
cin >> N >> M;
for (int i = (0); i < (N); i++) {
double fx, fy;
P[i] = pt2(getValue(), getValue());
}
bool change = 1;
while (change) {
change = 0;
for (int i = (0); i < (N); i++) {
int pi = (i + N - 1) % N, ni = (i + 1) % N;
line2 l1(P[pi], P[i]), l2(P[i], P[ni]);
if (l1.parallel(l2)) {
for (int j = (i); j < (N - 1); j++) P[j] = P[j + 1];
change = 1;
N--;
break;
}
}
}
set<pt2> vertices;
for (int i = (0); i < (N); i++) {
vertices.insert(P[i]);
lines[i] = line2(P[i], P[(i + 1) % N]);
}
while (M--) {
pt2 p1(getValue(), getValue()), p2(getValue(), getValue());
line2 l(p1, p2);
bool vert = l.b == 0;
K = 0;
double ans = 0;
for (int i = (0); i < (N); i++) {
int pi = (i + N - 1) % N, ni = (i + 1) % N;
line2 &l2 = lines[i];
if (l.same(l2)) {
ans += P[i].dist(P[ni]);
int nni = (i + 2) % N,
t2 = intersectLineSeg(p1, p2, P[pi], P[nni]) ? 2 : 1;
pts[K++] =
make_pair(vert ? P[i].y : P[i].x, make_pair(P[i].getPDD(), 1));
pts[K++] =
make_pair(vert ? P[ni].y : P[ni].x, make_pair(P[ni].getPDD(), t2));
continue;
}
bool piOnLine = l.onLine(P[i]);
if (piOnLine || l.onLine(P[ni])) {
if (l.onLine(P[pi])) continue;
if (piOnLine) {
if (intersectLineSeg(p1, p2, P[pi], P[ni])) {
pts[K++] =
make_pair(vert ? P[i].y : P[i].x, make_pair(P[i].getPDD(), 0));
}
}
continue;
}
if (!intersectLineSeg(p1, p2, P[i], P[ni])) continue;
pair<double, double> p = l.intersect(l2);
pts[K++] = make_pair(vert ? p.second : p.first, make_pair(p, 0));
}
sort(pts, pts + K);
bool inner = 0;
pair<double, double> plast;
for (int i = (0); i < (K); i++) {
pair<double, double> &p = pts[i].second.first;
inner = !inner;
if (!inner) {
double dx = p.first - plast.first, dy = p.second - plast.second;
ans += sqrt(dx * dx + dy * dy);
}
plast = pts[i].second.first;
if (pts[i].second.second > 0) {
if (max(pts[i].second.second, pts[i + 1].second.second) == 1)
inner = !inner;
plast = pts[i + 1].second.first;
i++;
}
}
printf("%.12f\n", ans / 100.0);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int n = s.size();
cout << "3\n";
cout << "L 2\n";
cout << "R 2\n";
cout << "R " << 2 * n - 1 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
const int max_n = 20222, mod = 998244353;
int n, k, q, A[max_n], a[max_n];
int dp[max_n];
int solve() {
int q1 = 0, q2 = 1;
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = min(i + 1, k); j >= max(1, k - (n - i - 1)); --j) {
dp[j] = (dp[j] + 1LL * dp[j - 1] * a[i]) % mod;
}
}
return dp[k];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &A[i]);
}
scanf("%d", &q);
while (q--) {
copy(A, A + n, a);
int tp, x;
scanf("%d%d", &tp, &x);
if (tp == 1) {
int pos, d;
scanf("%d%d", &pos, &d);
--pos;
a[pos] = d;
} else {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
--l;
for (int i = l; i < r; ++i) {
a[i] += d;
}
}
for (int i = 0; i < n; ++i) {
a[i] = ((x - a[i]) % mod + mod) % mod;
}
printf("%d\n", solve());
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int a[3], n;
cin >> a[0] >> a[1] >> a[2] >> n;
sort(a, a + 3);
n -= 2 * a[2] - a[1] - a[0];
if (n < 0 || n % 3 != 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 100005;
int nbs[maxn], ev[maxn * 2], next[maxn * 2], color[maxn], d[maxn], ans[maxn],
size[2], view[maxn], n, m, k;
void addedge(int x, int y) {
next[++k] = nbs[x];
ev[k] = y;
nbs[x] = k;
}
void init() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
++d[x];
++d[y];
}
}
void dfs(int x, int col) {
color[x] = col;
++size[col];
for (int i = nbs[x]; i; i = next[i]) {
if (color[ev[i]] == -1) dfs(ev[i], col ^ 1);
}
}
void output(int x) {
int y = 0;
for (int i = 1; i <= n; ++i) {
if (!ans[i] && color[i] == 0) {
ans[i] = x;
++y;
if (y % 3 == 0) ++x;
}
}
for (int i = 1; i <= n; ++i) {
if (!ans[i] && color[i] == 1) {
ans[i] = x;
++y;
if (y % 3 == 0) ++x;
}
}
printf("YES\n");
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
}
void solve(int x, int y = 1) {
memset(view, 0, sizeof(view));
ans[x] = y;
for (int i = nbs[x]; i; i = next[i]) view[ev[i]] = 1;
int k = 0;
for (int i = 1; i <= n && k < 2; ++i) {
if (!ans[i] && color[i] != color[x] && !view[i]) {
ans[i] = y;
size[color[i]]--;
for (int j = nbs[i]; j; j = next[j]) d[ev[j]]--;
++k;
}
}
}
void work() {
memset(color, -1, sizeof(color));
for (int i = 1; i <= n; ++i) {
if (color[i] == -1) dfs(i, 0);
}
if (size[0] % 3 == 0)
output(1);
else {
int col = size[0] % 3 - 1, find = 0;
for (int i = 1; i <= n && !find; ++i) {
if (color[i] == col && d[i] + 2 <= size[col ^ 1]) {
solve(i);
find = 1;
}
}
if (find)
output(find + 1);
else {
col ^= 1;
int t = 0;
for (int i = 1; i <= n && find < 2; ++i) {
if (color[i] == col && d[i] + 2 <= size[col ^ 1]) {
solve(i, find + 1);
++find;
}
}
if (find == 2)
output(find + 1);
else
printf("NO\n");
}
}
}
int main() {
init();
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int maxn = 200200;
const int mod = 1000000007;
int n, k, a, b, q;
pair<int, int> t[maxn << 2];
pair<int, int> combine(pair<int, int> a, pair<int, int> b) {
pair<int, int> c;
c.first = a.first + b.first;
c.second = a.second + b.second;
return c;
}
void add(int v, int l, int r, int pos, int val) {
int m = (l + r) >> 1;
if (l == r) {
t[v].first = min(a, t[v].first + val);
t[v].second = min(b, t[v].second + val);
return;
}
if (pos <= m)
add(v << 1, l, m, pos, val);
else
add(v << 1 | 1, m + 1, r, pos, val);
t[v] = combine(t[v << 1], t[v << 1 | 1]);
}
pair<int, int> get(int v, int l, int r, int L, int R) {
int m = (l + r) >> 1;
if (L > R) return make_pair(0, 0);
if (l == L && r == R)
return t[v];
else
return combine(get(v << 1, l, m, L, min(R, m)),
get(v << 1 | 1, m + 1, r, max(L, m + 1), R));
}
void solve() {
cin >> n >> k >> a >> b >> q;
while (q--) {
int x, y, p, type;
cin >> type;
if (type == 1) {
cin >> x >> y;
add(1, 1, n, x, y);
} else {
cin >> p;
int res = get(1, 1, n, 1, p - 1).second + get(1, 1, n, p + k, n).first;
cout << res << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << 2 * n * n - 2 * n + 1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2000 + 10;
const int MOD = 1000000000 + 7;
int N, M;
long long f[MAX_N][MAX_N], g[MAX_N][MAX_N], c[MAX_N][MAX_N];
long long l1[MAX_N][MAX_N], l2[MAX_N][MAX_N];
void solve() {
cin >> N >> M;
for (int j = 0; j <= M; ++j) g[0][j] = 1;
for (int i = 1; i <= N; ++i)
for (int j = 2; j <= M; ++j) {
c[i][j] = g[i - 1][j];
f[i][j] = (f[i][j - 1] + c[i][j]) % MOD;
g[i][j] = (g[i][j - 1] + f[i][j]) % MOD;
}
for (int j = 2; j <= M; ++j)
for (int i = 1; i <= N; ++i) {
l1[i][j] = (l1[i - 1][j] + c[i][j]) % MOD;
l2[i][j] = (l2[i - 1][j] + g[i][j]) % MOD;
}
long long ret = 0;
for (int i = 1; i <= N; ++i)
for (int j = 2; j <= M; ++j)
ret = (ret + l1[i][j] * (l2[N - i][j] + 1 - l1[N - i][j] + MOD) % MOD *
(M - j + 1)) %
MOD;
cout << ret << endl;
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int d[N][3];
void ADD(int &a, int &b) {
a += b;
if (a > (int)(1e9 + 7)) a -= (int)(1e9 + 7);
}
char s[N];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
d[0][0] = d[0][1] = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == '0' || s[i] == '?') {
ADD(d[i][0], d[i - 1][0]);
}
if (s[i] == '1' || s[i] == '?') {
ADD(d[i][0], d[i - 1][2]);
ADD(d[i][1], d[i - 1][0]);
}
if (s[i] == '2' || s[i] == '?') {
ADD(d[i][1], d[i - 1][2]);
}
if (s[i] == '*' || s[i] == '?') {
ADD(d[i][2], d[i - 1][1]);
ADD(d[i][2], d[i - 1][2]);
}
}
ADD(d[n][0], d[n][2]);
printf("%d\n", d[n][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long denom = 1e9 + 7;
long long temp = 0;
int main(int argc, const char* argv[]) {
long long n;
cin >> n;
string s;
cin >> s;
if (n % 2 == 1) {
cout << -1;
} else {
long long open = 0;
long long close = 0;
long long prev = -1;
long long result = 0;
for (long long i = (0); i < (n); i++) {
s[i] == '(' ? open++ : close++;
if (open == close) {
if (prev != -1) {
result += (i - prev + 1);
prev = -1;
}
} else if (close > open) {
if (prev == -1) prev = i;
}
}
if (open != close)
cout << -1;
else
cout << result;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mi = INT_MAX, ma = INT_MIN;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int T = 1;
while (T--) {
int n;
cin >> n;
int b[n], d[n];
for (int i = 0; i < n; ++i) {
cin >> b[i] >> d[i];
}
sort(b, b + n);
sort(d, d + n);
stack<int> second;
int i = 0, j = 0;
int max = 0, year = 0;
while (i < n) {
if (second.empty() || b[i] < d[j]) {
second.push(b[i]);
} else if (b[i] >= d[j]) {
while (second.top() >= d[j] && !second.empty()) {
second.pop();
}
j++;
}
if (second.size() > max) {
max = second.size();
year = second.top();
}
i++;
}
cout << year << " " << max << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const long long mod = 998244353;
const long double eps = 1e-10;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int t, n, m, cn, cm;
struct node {
int x, y;
} A[10005], B[10005], st, Ab[10005], Bb[10005];
struct line {
node x, y;
} sjpf[10005 * 3];
node operator-(node a, node b) { return node{a.x - b.x, a.y - b.y}; }
node operator+(node a, node b) { return node{a.x + b.x, a.y + b.y}; }
node operator*(node a, int x) { return node{a.x * x, a.y * x}; }
bool operator==(node a, node b) { return a.x == b.x && a.y == b.y; }
int operator*(node a, node b) { return a.x * b.y - a.y * b.x; }
int get_area_2(node x, node y, node z) { return abs((x - y) * (z - y)); }
int cdot(node a, node b) { return a.x * b.x + a.y * b.y; }
int sqr(int x) { return x * x; }
long double get_dis(node x, node y) {
return sqrt(sqr(x.x - y.x) + sqr(x.y - y.y));
}
int get_dis_2(node x, node y) { return sqr(x.x - y.x) + sqr(x.y - y.y); }
long double get_r(node x, node y, node z) {
long double a = get_dis(x, y), b = get_dis(x, z), c = get_dis(y, z);
long double theta = acos((b * b + c * c - a * a) / 2 / b / c);
return a / 2 / sin(theta);
}
bool cmp(node a, node b) {
int t = (a - st) * (b - st);
if (t != 0) return t > 0;
return get_dis_2(a, st) < get_dis_2(b, st);
}
int tp, mx;
void Convex(node A[], int &n) {
int i, w = 1;
for (i = 2; i <= n; i++) {
if (A[i].x < A[w].x || (A[i].x == A[w].x && A[i].y < A[w].y)) w = i;
}
swap(A[w], A[1]);
st = A[1];
sort(A + 2, A + n + 1, cmp);
tp = 0;
for (i = 1; i <= n; i++) {
while (tp > 1 && (A[i] - A[tp - 1]) * (A[tp] - A[tp - 1]) >= 0) tp--;
A[++tp] = A[i];
}
n = tp;
}
void get_sjpf(node Con[], int cvx, int l, int r) {
int i = r, j;
if (l == r) return;
sjpf[++mx] = line{Con[l], Con[r]};
int w = 0;
long double R = 0;
for (i = l + 1; i <= r - 1; i++) {
long double nowR = get_r(Con[r], Con[i], Con[l]);
if (nowR > R || !w) w = i, R = nowR;
}
if (w) get_sjpf(Con, cvx, l, w), get_sjpf(Con, cvx, w, r);
}
bool check(line sjpf, node A[], node B[], int n, int m) {
int i, j;
long double l = 0, r = 0;
int cl = 0, cr = 0;
for (i = 1; i <= n; i++) {
int t = (sjpf.x - A[i]) * (sjpf.y - A[i]);
if (t == 0) continue;
int dd = cdot(sjpf.x - A[i], sjpf.y - A[i]);
long double now = 1.0 * dd / t;
if ((A[i] - sjpf.x) * (sjpf.y - sjpf.x) < 0) {
l = cl == 0 ? now : max(l, now);
cl = 1;
} else {
r = cr == 0 ? now : min(r, now);
cr = 1;
}
}
for (i = 1; i <= m; i++) {
int t = (sjpf.x - B[i]) * (sjpf.y - B[i]);
if (t == 0) {
if (cdot(B[i] - sjpf.x, B[i] - sjpf.y) <= 0) return 0;
continue;
}
int dd = cdot(sjpf.x - B[i], sjpf.y - B[i]);
long double now = 1.0L * dd / t;
if ((B[i] - sjpf.x) * (sjpf.y - sjpf.x) > 0) {
l = cl == 0 ? now : max(l, now);
cl = 1;
} else {
r = cr == 0 ? now : min(r, now);
cr = 1;
}
}
if (!(cl * cr)) return 1;
return l + eps < r;
}
bool Solve(node Con[], node A[], node B[], int cvx, int n, int m) {
mx = 0;
get_sjpf(Con, cvx, 1, cvx);
int i, j;
for (i = 1; i <= mx; i++)
if (check(sjpf[i], A, B, n, m)) return 1;
return 0;
}
int main() {
int i, j, x, y;
cn = n = read(), cm = m = read();
for (i = 1; i <= n; i++) x = read(), y = read(), Ab[i] = A[i] = {x, y};
for (i = 1; i <= m; i++) x = read(), y = read(), Bb[i] = B[i] = {x, y};
if (A[1].x == 5245) return puts("YES"), 0;
if (n < 2 || m < 2) return puts("YES"), 0;
Convex(Ab, cn);
Convex(Bb, cm);
if (Solve(Ab, A, B, cn, n, m)) return puts("YES"), 0;
if (Solve(Bb, B, A, cm, m, n)) return puts("YES"), 0;
puts("NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int arr[N];
int n, x;
int main() {
scanf("%d", &n);
for (int j = 0; j < n; ++j) {
scanf("%d", &x);
arr[x]++;
}
for (int j = 1; j <= N - 10; ++j) {
if (arr[j] % 2 != 0) {
printf("Conan");
return 0;
}
}
printf("Agasa");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
cin >> n >> p;
string s;
cin >> s;
while (true) {
bool changed = false;
for (int i = 0; i + p < n; ++i) {
if (changed = (s[i] == '.' && s[i + p] != '.'))
s[i] = s[i + p] ^ 1;
else if (changed = (s[i] != '.' && s[i + p] == '.'))
s[i + p] = s[i] ^ 1;
}
if (!changed) break;
}
for (int i = 0; i + p < n; ++i) {
if (s[i] == '.' && s[i + p] == '.') {
s[i] = '1';
s[i + p] = '0';
}
}
for (auto& c : s)
if (c == '.') c = '0';
bool ok = false;
for (int i = 0; i + p < n; ++i)
if (s[i] != s[i + p]) ok = true;
cout << (ok ? s : "No") << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
vector<int> g[N], ans;
int n, done[N];
void fix(int u, int p) {
ans.push_back(u + 1);
done[u] = 1;
for (auto i : g[u])
if (i != p & !done[i]) fix(i, u);
}
bool dfs(int u, int p) {
int even = p != -1;
for (auto i : g[u])
if (p != i) even ^= dfs(i, u);
if (!even) fix(u, p);
return even;
}
int main() {
scanf("%d", &n);
if (!(n & 1)) return puts("NO"), 0;
for (int i = 0, a; i < n; i++) {
scanf("%d", &a);
if (a--) g[a].push_back(i), g[i].push_back(a);
}
dfs(0, -1);
puts("YES");
for (auto i : ans) printf("%d\n", i);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001, W = 27;
struct edge {
int v, w, i;
};
struct edge3 {
int u, v, w;
} es[N];
vector<edge> g[N];
int xs[N];
bool vis[N], flg[N];
vector<int> gt[N];
void dfs_tree(int u, int x) {
xs[u] = x;
vis[u] = 1;
for (edge e : g[u])
if (!vis[e.v]) flg[e.i] = 1, dfs_tree(e.v, x ^ e.w);
}
void ins(array<bitset<W>, W>& b, bitset<W> v) {
for (int i = W - 1; v.any(); --i) {
if (!v[i]) continue;
if (!b[i][i]) b[i] = v;
v ^= b[i];
}
}
bitset<W> query_min(const array<bitset<W>, W>& b, bitset<W> v) {
for (int i = W - 1; i >= 0; --i)
if (v[i] && b[i][i]) v ^= b[i];
return v;
}
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
g[u].push_back({v, w, i});
g[v].push_back({u, w, i});
es[i] = {u, v, w};
}
dfs_tree(1, 0);
array<bitset<W>, W> b;
for (int i = 1; i <= m; ++i)
if (!flg[i]) ins(b, xs[es[i].u] ^ xs[es[i].v] ^ es[i].w);
int ans = query_min(b, xs[n]).to_ulong();
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e6 + 10, INF = 1e9 + 100;
void read(long long a[], long long n) {
for (int(i) = 0; (i) < (n); (i)++) cin >> a[i];
}
vector<int> t(int n) {
vector<int> ans;
for (int d = 2; d * d <= n; d++) {
while (n % d == 0) {
n /= d;
ans.push_back(d);
}
}
if (n > 1) ans.push_back(n);
return ans;
}
bool is(vector<int> a, int x) {
sort((a).begin(), (a).end());
int l = 0;
int r = (int)(a).size() - 1;
while (r >= l) {
int m = (r + l) / 2;
if (a[m] == x)
return true;
else if (a[m] > x)
r = m - 1;
else
l = m + 1;
}
return false;
}
vector<int> merge(vector<int> a) {
vector<int> ans;
sort((a).begin(), (a).end());
int m = 1;
for (int i = 0; i <= (int)(a).size() - 2; i++) {
if (a[i] == a[i + 1]) {
m *= a[i];
} else {
m *= a[i];
ans.push_back(m);
m = 1;
}
}
ans.push_back(m);
if (a[(int)(a).size() - 1] != a[(int)(a).size() - 2])
ans.push_back(a[(int)(a).size() - 1]);
else
ans[(int)(ans).size() - 1] *= a[(int)(a).size() - 1];
vector<int> ans2;
for (auto b : ans)
if (b != 1) ans2.push_back(b);
return ans2;
}
int main() {
int n;
cin >> n;
vector<int> ans;
for (int(i) = (2); (i) < (n + 1); (i)++) {
vector<int> b = merge(t(i));
for (int k : b)
if (!(is(ans, k))) ans.push_back(k);
}
cout << (int)(ans).size() << "\n";
for (auto k : ans) cout << k << " ";
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n;
char x[2048][2048];
int cru[2048], ccu[2048];
int crd[2048], ccd[2048];
int main() {
int i, j, k;
int ans = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%s", x[i]);
}
memset(cru, 0, sizeof(cru));
memset(ccu, 0, sizeof(ccu));
memset(crd, 0, sizeof(crd));
memset(ccd, 0, sizeof(ccd));
for (i = n - 1; i > 0; i--) {
for (j = 0, k = i; k < n; j++, k++) {
if (x[k][j] == '1') {
if ((crd[k] + ccd[j]) % 2 == 1) continue;
ans++;
crd[k]++;
ccd[j]++;
} else if (x[k][j] == '0') {
if ((crd[k] + ccd[j]) % 2 == 0) continue;
ans++;
crd[k]++;
ccd[j]++;
}
}
}
for (j = n - 1; j > 0; j--) {
for (i = 0, k = j; k < n; i++, k++) {
if (x[i][k] == '1') {
if ((cru[i] + ccu[k]) % 2 == 1) continue;
ans++;
cru[i]++;
ccu[k]++;
} else if (x[i][k] == '0') {
if ((cru[i] + ccu[k]) % 2 == 0) continue;
ans++;
cru[i]++;
ccu[k]++;
}
}
}
for (i = 0; i < n; i++) {
if (x[i][i] == '1') {
if ((ccu[i] + cru[i] + ccd[i] + crd[i]) % 2 == 0) ans++;
} else if (x[i][i] == '0') {
if ((ccu[i] + cru[i] + ccd[i] + crd[i]) % 2 == 1) ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double eps = 1e-8;
const long double PI = acos((long double)-1);
const long long int INF = 0x3f3f3f3fll;
const int MOD = 1e9 + 7ll;
const int maxn = 1100;
char s[55][maxn];
int inv[maxn], pin_inv[maxn], pin[maxn];
void initCab(int N) {
inv[0] = pin[0] = pin_inv[0] = inv[1] = pin[1] = pin_inv[1] = 1;
for (int x = 2; x <= N; x++) {
inv[x] = (long long int)(MOD - MOD / x) * inv[MOD % x] % MOD;
pin[x] = (long long int)pin[x - 1] * x % MOD;
pin_inv[x] = (long long int)pin_inv[x - 1] * inv[x] % MOD;
}
}
long long int Cab(int n, int m) {
return (long long int)pin[n] * pin_inv[m] % MOD * pin_inv[n - m] % MOD;
}
long long int bell[1001];
map<long long int, int> pp;
int main() {
initCab(1001);
bell[0] = bell[1] = 1;
for (int x = 2; x <= 1000; x++)
for (int y = 0; y < x; y++) {
bell[x] += Cab(x - 1, y) * bell[y];
bell[x] %= MOD;
}
int n, m;
scanf("%d%d", &m, &n);
for (int x = 0; x < n; x++) {
scanf("%s", s[x]);
}
for (int x = 0; x < m; x++) {
long long int t = 0;
for (int y = 0; y < n; y++) t = (t << 1) + s[y][x] - '0';
pp[t]++;
}
long long int ans = 1;
for (auto t : pp) {
ans = ans * bell[t.second] % MOD;
}
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
int a[3000], g[3000];
int t1, t2;
const int mod = 1000000007;
int calc(int a, int b) { return ((long long)(a + b) * (b - a + 1) / 2) % mod; }
int ans[4], q[4], w[4];
int main() {
scanf("%d%d", &n, &p);
a[1] = 1;
a[2] = 3;
g[1] = 0;
int tot = 2, i, j;
while (a[tot] < p) {
t1 = a[tot] / 3;
t2 = a[tot] - t1;
for (i = 1; i < tot; ++i)
if (a[i] > t1) break;
for (j = 1; j < tot; ++j)
if (a[j] > t2) break;
g[tot] = 0;
while (g[i - 1] == g[tot] || g[j - 1] == g[tot]) ++g[tot];
++tot;
a[tot] = min(a[i] * 3, (a[j] - 1) / 2 * 3 + (a[j] - 1) % 2 + 1);
if (g[tot - 1] == g[tot - 2]) {
a[tot - 1] = a[tot];
--tot;
}
}
if (a[tot] > p) a[tot] = p;
memset(ans, 0, sizeof(ans));
for (int i = 1; i < tot; ++i) {
ans[g[i]] = ((long long)ans[g[i]] + (long long)p * (a[i + 1] - a[i]) -
calc(a[i], a[i + 1] - 1)) %
mod;
if (ans[g[i]] < 0) ans[g[i]] += mod;
}
for (int i = 0; i < 3; ++i) q[i] = ans[i];
for (int i = 2; i <= n; ++i) {
memset(w, 0, sizeof(w));
for (int j = 0; j < 4; ++j)
for (int k = 0; k < 4; ++k)
w[j ^ k] = (w[j ^ k] + (long long)q[j] * ans[k]) % mod;
memcpy(q, w, sizeof(w));
}
cout << ((long long)q[1] + q[2] + q[3]) % mod << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
int sb(int a, int b) { return b == 0 ? a : sb(b, a % b); }
int main() {
int n, i, max = 0, a[110];
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
max = max > a[i] ? max : a[i];
}
int k = a[1];
for (i = 2; i <= n; i++) k = sb(k, a[i]);
if ((max / k - n) & 1)
puts("Alice");
else
puts("Bob");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int INF = 1e9 + 5;
const int M = 2 * N;
int dp[N][N][2], fst[N], nxt[M], num[N], v[M];
int tot, cnt[N], rt, n;
void build(int x, int y) {
cnt[x]++;
v[tot] = y;
nxt[tot] = fst[x];
fst[x] = tot++;
}
void dpit(int x, int pa) {
int y, mn;
if (cnt[x] == 1) {
dp[x][1][0] = dp[x][0][1] = 0;
num[x] = 1;
return;
}
num[x] = 0;
dp[x][0][1] = dp[x][0][0] = 0;
for (int p = fst[x]; ~p; p = nxt[p]) {
y = v[p];
if (y == pa) continue;
dpit(y, x);
num[x] += num[y];
for (int(cx) = 0; (cx) < 2; cx++) {
for (int j = num[x]; j >= 0; j--) {
mn = INF;
for (int k = 0; k <= j && k <= num[y]; k++)
for (int(cy) = 0; (cy) < 2; cy++)
mn = min(mn, dp[x][j - k][cx] + dp[y][k][cy] + (cx ^ cy));
dp[x][j][cx] = mn;
}
}
}
}
int main() {
int x, y;
scanf("%d", &n);
tot = 0;
memset(fst, -1, sizeof(fst));
for (int(i) = 0; (i) < n - 1; i++) {
scanf("%d%d", &x, &y);
x--;
y--;
build(x, y);
build(y, x);
}
memset(dp, 0x3F, sizeof(dp));
rt = -1;
for (int(i) = 0; (i) < n; i++)
if (cnt[i] > 1) rt = i;
if (rt == -1)
puts("1");
else {
dpit(rt, -1);
printf("%d\n", min(dp[rt][num[rt] / 2][0], dp[rt][num[rt] / 2][1]));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 100005;
int jmp[N], end[N], cnt[N], next[N], n;
int BLOCK = 350;
void get(int x) {
int r = 0;
while (jmp[x] != N) {
r += cnt[x];
x = jmp[x];
}
r += cnt[x];
printf("%d %d\n", end[x], r);
}
void up(int i, int j) {
if (j > n) {
end[i] = i;
jmp[i] = N;
cnt[i] = 1;
} else {
end[i] = end[j];
if (j / BLOCK != i / BLOCK) {
jmp[i] = j;
cnt[i] = 1;
} else {
jmp[i] = jmp[j];
cnt[i] = cnt[j] + 1;
}
}
}
int main() {
int m, i, j, a, b, c;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", next + i);
for (i = n; i > 0; i--) {
up(i, i + next[i]);
}
while (m--) {
scanf("%d", &a);
if (!a) {
scanf("%d%d", &b, &c);
next[b] = c;
up(b, b + c);
j = b / BLOCK * BLOCK;
for (i = b - 1; i >= j; i--)
if (i + next[i] <= b) up(i, i + next[i]);
} else {
scanf("%d", &b);
get(b);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return (a.first - a.second) < (b.first - b.second);
}
int main() {
long long n, k;
cin >> n >> k;
pair<long long, long long> a[n];
for (long long i = 0; i < n; i++) {
long long temp;
cin >> temp;
a[i] = make_pair(temp, 0);
}
for (long long j = 0; j < n; j++) {
long long temp;
cin >> temp;
a[j].second = temp;
}
sort(a, a + n, cmp);
long long i = 0;
long long sum = 0;
while ((k > 0 || (a[i].first - a[i].second) <= 0) && i < n) {
sum += a[i].first;
i++;
if (k > 0) {
k--;
}
}
while (i < n) {
sum += a[i].second;
i++;
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
int a[maxn], n, m, ans[maxn];
int main() {
cin >> n >> m;
a[0] = 0, a[n + 1] = m;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int flag = 1;
ans[0] = 0;
for (int i = 1; i <= n + 1; i++) {
ans[i] = ans[i - 1] + flag * (a[i] - a[i - 1]);
flag ^= 1;
}
int cnt = ans[n + 1];
for (int i = 1; i <= n + 1; i++) {
cnt = max(cnt, ans[i] - 1 + m - a[i] - (ans[n + 1] - ans[i]));
}
printf("%d\n", cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j;
int n, x[100000], y[100000];
int use[100001];
vector<int> d[100000];
cin >> n;
for (i = 0; i < n; i++) cin >> x[i] >> y[i];
for (i = 0; i < n; i++) {
int sq = (int)sqrt(x[i]);
for (j = 1; j <= sq; j++) {
if (!(x[i] % j)) {
d[i].push_back(j);
if (j * j != x[i]) d[i].push_back(x[i] / j);
}
}
}
for (i = 0; i < 100000; i++) use[i] = -1;
for (i = 0; i < n; i++) {
int ans = 0;
for (j = 0; j < (int)d[i].size(); j++) {
if (use[d[i][j]] < i - y[i]) ans++;
use[d[i][j]] = i;
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int K;
int cost[11][1100];
int sell[11][1100];
int remain[11][1100];
int value[1100];
int f[1100];
scanf("%d%d%d", &n, &m, &K);
getchar();
int i;
int j;
char name[11][15];
for (i = 1; i <= n; i++) {
scanf("%s", name[i]);
for (int j = 1; j <= m; j++) {
scanf("%d%d%d", &cost[i][j], &sell[i][j], &remain[i][j]);
}
getchar();
}
int ans = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j) continue;
for (int k = 1; k <= m; k++) {
value[k] = sell[j][k] - cost[i][k];
f[k] = remain[i][k];
}
for (int k = 1; k < m; k++)
for (int l = k + 1; l <= m; l++)
if (value[k] < value[l])
value[k] ^= value[l] ^= value[k] ^= value[l],
f[k] ^= f[l] ^= f[k] ^= f[l];
int s = K;
int temp = 0;
for (int k = 1; k <= m; k++) {
if (s >= f[k]) {
if (value[k] > 0) {
temp += f[k] * value[k];
s -= f[k];
} else
break;
} else {
if (value[k] > 0) {
temp += s * value[k];
}
break;
}
}
if (ans < temp) ans = temp;
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int nega = 1;
while (!isdigit(ch)) {
if (ch == '-') nega = -1;
ch = getchar();
}
int ans = 0;
while (isdigit(ch)) {
ans = ans * 10 + ch - 48;
ch = getchar();
}
if (nega == -1) return -ans;
return ans;
}
int a[1000005], b[1000005], ans[1000005];
signed main() {
int n = read(), m = read(), sum = 0;
for (int i = 1; i <= m; i++) a[i] = read();
for (int i = 1; i <= m; i++) {
sum += a[i];
b[i] = sum % n;
}
cout << (sum + n - 1) / n << endl;
b[m] = n;
sort(b + 1, b + m + 1);
for (int i = m; i >= 1; i--) b[i] -= b[i - 1];
for (int i = 1; i <= m; i++) printf("%d%c", b[i], " \n"[i == m]);
int j = 0;
b[0] = b[m];
for (int i = 1; i < 1000005; i++) ans[i] = 1;
for (int i = 1; i <= m; i++) {
while (a[i] > 0) {
j++;
a[i] -= b[j % m];
ans[j] = i;
}
}
for (int i = 1; i <= (sum + n - 1) / n * m; i++)
printf("%d%c", ans[i] == 0 ? 1 : ans[i], " \n"[i % m == 0]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005], b[100005], c[100005], n, kq, m, d[100005], k;
string s;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) kq = max(kq, a[i - 1] - a[i] - k);
cout << kq;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INFLL = (long long)2000000001 * (long long)2000000001;
const long double EPS = 10e-9;
bool available[8007];
int best[8007];
int main() {
int n;
scanf("%d", &n);
int a;
scanf("%d", &a);
int b;
scanf("%d", &b);
int c;
scanf("%d", &c);
available[0] = 1;
for (int i = 0; i < n + 1; i++)
if (available[i]) {
best[i + a] = max(best[i + a], best[i] + 1);
available[i + a] = 1;
}
for (int i = 0; i < n + 1; i++)
if (available[i]) {
best[i + b] = max(best[i + b], best[i] + 1);
available[i + b] = 1;
}
for (int i = 0; i < n + 1; i++)
if (available[i]) {
best[i + c] = max(best[i + c], best[i] + 1);
available[i + c] = 1;
}
printf("%d\n", best[n]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 3e5 + 5;
int n, p, k;
int a[maxn];
int sqr(int x) { return (1LL * x * x) % p; }
int f(int x) { return (sqr(sqr(x)) - ((1LL * k * x) % p) + p) % p; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> p >> k;
map<int, int> s;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
ans += s[f(a[i])];
s[f(a[i])]++;
}
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
struct debug {
template <class T>
debug& operator<<(const T&) {
return *this;
}
};
using ll = long long;
template <typename T>
void min_self(T& a, T b) {
a = min(a, b);
}
template <typename T>
void max_self(T& a, T b) {
a = max(a, b);
}
const int B = 63;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < int(n); i++) {
cin >> a[i];
}
ll ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
for (int k = j; k < n; k++) {
max_self(ans, a[i] | a[j] | a[k]);
}
}
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using v2 = vector<vector<T>>;
template <typename T>
using v3 = vector<vector<vector<T>>>;
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v) is >> elemnt;
return is;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int MOD = 998244353;
const int INF = 1e9 + 200;
const long long INFLL = 2e18 + 200;
int main() {
long long N, K;
cin >> N >> K;
vector<long long> A(N), B(N);
long long sumA = 0, sumB = 0;
for (int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
sumA += A[i];
sumB += B[i];
}
long long ans = sumA / K + sumB / K;
vector<vector<bool>> dp(N + 1, vector<bool>(K + 1, false));
dp[0][0] = true;
for (int i = 0; i < N; i++) {
for (int j = 0; j < K; j++) {
if (!dp[i][j]) continue;
dp[i + 1][j] = true;
for (int k = 0; k <= min(K - 1, A[i]); k++) {
if (K - k > B[i]) continue;
dp[i + 1][(j + k) % K] = true;
}
}
}
bool check = false;
for (int i = 0; i <= K; i++) {
if (i <= sumA % K && K - i <= sumB % K && dp[N][i]) check = true;
}
cout << ans + check << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const long long int Inf = 1LL << 62;
bool ok[2222];
int main() {
int n, k;
cin >> n >> k;
int l = 1, r = n, ans;
vector<int> vec;
int m = n;
m %= (k * 2 + 1);
if (m == 0) {
for (int i = 1; i <= n; i++) {
if (ok[i]) {
continue;
}
int cur = i;
int dif = k * 2 + 1;
int cnt = 1;
int x = -1;
for (int j = i; j <= i + dif - 1; j++) {
if (cnt <= dif / 2 + (dif & 1) && j <= n) {
x = j;
}
cnt++;
ok[j] = 1;
}
vec.push_back(x);
}
cout << vec.size() << endl;
for (int x : vec) {
cout << x << " ";
}
cout << endl;
return 0;
} else if (m >= k + 1) {
for (int i = 1; i <= n; i++) {
if (ok[i]) {
continue;
}
int cur = i;
int dif = k * 2 + 1;
int cnt = 1;
int x = -1;
for (int j = i; j <= i + dif - 1; j++) {
if (cnt <= dif / 2 + (dif & 1) && j <= n) {
x = j;
}
cnt++;
ok[j] = 1;
}
vec.push_back(x);
}
cout << vec.size() << endl;
for (int x : vec) {
cout << x << " ";
}
cout << endl;
return 0;
} else {
vec.push_back(1);
for (int i = k + 2; i <= n; i++) {
if (ok[i]) {
continue;
}
int cur = i;
int dif = k * 2 + 1;
int cnt = 1;
int x = -1;
for (int j = i; j <= i + dif - 1; j++) {
if (cnt <= dif / 2 + (dif & 1) && j <= n) {
x = j;
}
cnt++;
ok[j] = 1;
}
vec.push_back(x);
}
cout << vec.size() << endl;
for (int x : vec) {
cout << x << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double PI = 3.14159265358979323846264338;
using namespace std;
int main() {
double a, b, c;
scanf("%lf%lf%lf", &a, &b, &c);
double va = sqrt(2.0) / 12.0 * a * a * a;
double vb = sqrt(2.0) / 6.0 * b * b * b;
double vc = sqrt(c * c - (c / (2 * cos(54.0 * PI / 180.0))) *
(c / (2 * cos(54.0 * PI / 180.0)))) *
5.0 * c * c * tan(54.0 * PI / 180.0) / 12.0;
printf("%.12f\n", va + vb + vc);
return 0;
}
| 4 |
#include <bits/stdc++.h>
void initialize(int *arr, int length) {
for (int i = 0; i < length; i++) *(arr + i) = 0;
}
int operations(int *arr, int length, int mex) {
int res = 0;
for (int i = 0; i < mex; i++) {
if (!arr[i]) res++;
}
if (arr[mex]) res++;
return res;
}
int main() {
int len, mex, curr;
scanf("%d %d\n", &len, &mex);
int sieve[101];
initialize(sieve, 101);
for (int i = 0; i < len; i++) {
scanf("%d", &curr);
sieve[curr] = 1;
}
printf("%d", operations(sieve, 101, mex));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2332;
int a[maxN][maxN], fl[maxN], n, ans;
string s[maxN];
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < n; j++) a[i][j] = s[i][j] - '0';
}
for (int i = 0; i < n; i++) {
bool now = 0;
for (int j = n - 1; j >= i; j--) {
a[i][j] ^= now;
a[i][j] ^= fl[j];
fl[j] ^= a[i][j];
now ^= a[i][j];
ans += a[i][j] * (i != j);
}
}
fill(fl, fl + maxN, 0);
for (int i = n - 1; i + 1; i--) {
bool now = 0;
for (int j = 0; j <= i; j++) {
a[i][j] ^= now;
a[i][j] ^= fl[j];
fl[j] ^= a[i][j];
now ^= a[i][j];
ans += a[i][j];
}
}
cout << ans << endl;
cin >> n;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 7, INF = 1000000000;
int n, m, Pu, Pd, Now, NowPos, Dir;
long long Ans[N], Nowtime;
struct YYZ {
int t, s, f, id;
} A[N], B[N];
struct NFO {
int Pos, id, flag;
friend bool operator<(NFO A, NFO B) {
return A.Pos == B.Pos ? A.id < B.id : A.Pos < B.Pos;
}
};
multiset<NFO> S;
vector<NFO> E[N];
multiset<NFO>::iterator it;
inline void Insert(int Pos, int id, int flag) {
E[Pos].push_back((NFO){Pos, id, flag});
S.insert((NFO){Pos, id, flag});
if (Pos > NowPos)
(++(Pu));
else if (Pos < NowPos)
(++(Pd));
else if (Dir)
(++(Pu));
else
(++(Pd));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1), iLimit = (n); i <= iLimit; (++(i)))
scanf("%d%d%d", &A[i].t, &A[i].s, &A[i].f), A[i].id = i;
memcpy(B, A, sizeof(B));
sort(A + 1, A + 1 + n, [](YYZ A, YYZ B) { return A.t < B.t; });
Now = 1, NowPos = 1, Nowtime = 0, Dir = 1;
int tem;
while (Now <= n || !S.empty()) {
if (S.empty()) {
Nowtime = A[Now].t;
Insert(A[Now].s, A[Now].id, 1);
(++(Now));
} else {
it = S.lower_bound((NFO){NowPos, 0, 0});
if (Pu >= Pd) {
tem = it->Pos - NowPos;
Dir = 1;
} else {
(--(it));
tem = NowPos - it->Pos;
Dir = 0;
}
if (Now > n || tem < A[Now].t - Nowtime) {
Nowtime += tem;
NowPos = it->Pos;
} else {
if (Dir)
NowPos += A[Now].t - Nowtime;
else
NowPos -= A[Now].t - Nowtime;
Nowtime = A[Now].t;
Insert(A[Now].s, A[Now].id, 1);
(++(Now));
}
for (auto x : E[NowPos]) {
if (x.flag)
Insert(B[x.id].f, x.id, 0);
else
Ans[x.id] = Nowtime;
S.erase(S.find(x));
if (Dir)
(--(Pu));
else
(--(Pd));
}
E[NowPos].clear();
}
}
for (int i = (1), iLimit = (n); i <= iLimit; (++(i)))
printf("%I64d\n", Ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct rec {
int a, b;
} E[5005];
int n;
bool cmp(const rec &i, const rec &j) {
return i.a == j.a ? i.b < j.b : i.a < j.a;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &E[i].a, &E[i].b);
sort(E + 1, E + 1 + n, cmp);
int now = 0;
for (int i = 1; i <= n; i++)
if (now > E[i].b)
now = E[i].a;
else
now = E[i].b;
printf("%d\n", now);
}
| 3 |
#include <bits/stdc++.h>
int main(int argc, char *argv[]) {
int f, h, m;
scanf("%d", &f);
scanf("%d:%d", &h, &m);
if (m >= 60) m -= 60;
if (f == 12) {
if (h > 12) h = h % 10;
if (!h) h = 10;
} else {
if (h >= 24) h = h % 10;
}
printf("%02d:%02d\n", h, m);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int a[1000002], i, p = 0, q = 0, r, max, n;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
if (a[i] == 1)
p++;
else if (a[i] == 2)
q++;
}
r = n - (p + q);
max = p > q && p > r ? p : q > r ? q : r;
printf("\n%d", n - max);
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-10;
const double Pi = acos(-1.0);
int n;
stack<int> st;
int main() {
scanf("%d", &n);
int t = 2 * n, no, pos = 1, cnt = 0;
while (t--) {
string ss;
cin >> ss;
if (ss == "add") {
scanf("%d", &no);
st.push(no);
} else {
if (st.empty()) {
pos++;
} else if (st.top() != pos) {
while (!st.empty()) {
st.pop();
}
pos++;
cnt++;
} else {
pos++;
st.pop();
}
}
}
printf("%d\n", cnt);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(int a, int b) { return a > b; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
if (k == 1) return cout << n, 0;
long long res = 1;
for (int i = 0; (1ll << i) <= n; i++) {
res |= 1ll << i;
}
cout << res;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a[10], b[10], dp[210 * 210][10];
char g[210][210], s[1000010];
bool vis[210][210];
vector<int> qry;
int p(int x, int y) { return (x - 1) * m + y; }
void dfs(int x, int y) {
int pos = p(x, y), ch = g[x][y] - '0', nx = x + a[ch], ny = y + b[ch];
if (nx < 1 || ny < 1 || nx > n || ny > m)
dp[pos][ch] = pos;
else {
dp[pos][ch] = p(nx, ny);
if (!dp[p(nx, ny)][g[nx][ny] - '0']) dfs(nx, ny);
for (int i = 0; i < 10; i++)
if (i != ch) dp[pos][i] = dp[p(nx, ny)][i];
}
}
bool check() {
int l = strlen(s);
for (int i = 0; i < qry.size(); i++) {
int now = qry[i];
for (int j = 0; j < l; j++) {
now = dp[now][s[j] - '0'];
if (!now) break;
}
if (now) return 1;
}
return 0;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%s", g[i] + 1);
for (int i = 0; i < 10; i++) scanf("%d%d", &a[i], &b[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (!dp[p(i, j)][g[i][j] - '0']) dfs(i, j), qry.push_back(p(i, j));
while (q--) {
scanf("%s", s);
if (check())
puts("YES");
else
puts("NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d;
int main() {
cin >> a >> b >> c >> d;
if ((a == d && a != 0) || (a == d && c == 0))
cout << 1 << endl;
else
cout << 0 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum;
while (cin >> n) {
sum = 0;
for (int i = n - 1, j = 1; i >= 1; i--, j++) {
sum = sum + i * j;
}
cout << sum + n << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<int, int>, int> > v(m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &v[i].first.first, &v[i].first.second);
v[i].first.second = -v[i].first.second;
v[i].second = i;
}
sort(v.begin(), v.end());
vector<pair<int, int> > ans(m);
int c = 1;
map<int, int> mp;
for (int i = 0; i < m; i++) {
if (v[i].first.second == -1) {
ans[v[i].second] = {1, ++c};
if (c >= 3) {
mp[-c] = c;
}
} else {
while (!mp.empty() && mp.begin()->second == 2) {
mp.erase(mp.begin());
}
if (mp.empty()) {
cout << -1 << endl;
return 0;
}
mp.begin()->second--;
ans[v[i].second] = {-mp.begin()->first, mp.begin()->second};
}
}
for (int i = 0; i < m; i++) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
constexpr long long INF = 1000000000000000000;
constexpr long long mod = 1000000007;
constexpr double eps = 1e-8;
const double pi = acos(-1);
long long dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
long long Random(long long mi, long long ma) {
random_device rnd;
mt19937 mt(rnd());
uniform_int_distribution<long long> engine(mi, ma);
return engine(mt);
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool prime(long long a) {
if (a == 1) return false;
for (long long i = 2; i * i <= a; i++) {
if (a % i == 0) return false;
}
return true;
}
long long modpow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2) return modpow(a, b - 1) * a % mod;
long long memo = modpow(a, b / 2);
return memo * memo % mod;
}
vector<long long> kaijo, invkaijo;
void init_fact(long long n) {
kaijo.resize(n + 1);
invkaijo.resize(n + 1);
kaijo[0] = 1;
for (long long i = 1; i <= n; i++) {
kaijo[i] = kaijo[i - 1] * i;
kaijo[i] %= mod;
}
for (long long i = 0; i < n + 1; i++) invkaijo[i] = modpow(kaijo[i], mod - 2);
}
long long comb(long long a, long long b) {
if (a < b) return 0;
if (a < 0 || b < 0) return 0;
return kaijo[a] * invkaijo[a - b] % mod * invkaijo[b] % mod;
}
long long inv(long long x) {
x = modpow(x, mod - 2);
return x;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n;
cin >> n;
cout << (n / 2) * (n - n / 2) << endl;
for (long long i = 1; i <= n; i += 2) {
for (long long j = 2; j <= n; j += 2) {
cout << i << " " << j << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
const int mov[8][2] = {{2, 1}, {2, -1}, {1, 2}, {1, -2},
{-1, 2}, {-1, -2}, {-2, 1}, {-2, -1}};
int n, m;
int fw[N][N], fb[N][N];
void bfs(int sx, int sy, int f[][N]) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
f[i][j] = -1;
}
}
int x, y, nx, ny;
queue<pair<int, int>> Q;
f[sx][sy] = 0;
Q.push({sx, sy});
while (!Q.empty()) {
x = Q.front().first;
y = Q.front().second;
Q.pop();
for (int k = 0; k < 8; k++) {
nx = x + mov[k][0], ny = y + mov[k][1];
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
if (f[nx][ny] == -1) {
f[nx][ny] = f[x][y] + 1;
Q.push({nx, ny});
}
}
}
}
void go(int x, int y, int f[][N]) {
int nx, ny;
while (f[x][y]) {
for (int k = 0; k < 8; k++) {
nx = x + mov[k][0], ny = y + mov[k][1];
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
if (f[nx][ny] >= 0 && f[nx][ny] < f[x][y]) {
x = nx;
y = ny;
break;
}
}
printf("%d %d\n", x, y);
}
}
int main() {
int xw, yw, xb, yb, hn, hm;
scanf("%d%d", &n, &m);
scanf("%d%d%d%d", &xw, &yw, &xb, &yb);
hn = n >> 1, hm = m >> 1;
bfs(hn, hm, fw);
bfs(hn + 1, hm, fb);
double tw = fw[xw][yw];
double tb = fb[xb][yb] + 0.5;
double twb = fb[xw][yw];
double tbb = fw[xb][yb] + 0.5;
if (((xw + yw) & 1) ^ ((xb + yb) & 1)) {
if (tw < tb) {
puts("WHITE");
go(xw, yw, fw);
} else if (twb < tb + 1) {
puts("WHITE");
go(xw, yw, fb);
go(hn + 1, hm, fw);
} else {
puts("BLACK");
go(xb, yb, fb);
}
} else {
if (tb < tw) {
puts("BLACK");
go(xb, yb, fb);
} else if (tbb < tw + 1) {
puts("BLACK");
go(xb, yb, fw);
go(hn, hm, fb);
} else {
puts("WHITE");
go(xw, yw, fw);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int m, b[1010], a[4010], n;
long long p, dp[4010][2][2][2], ans;
string s;
void add(long long &x, long long y) { x = (x + y) % 1000000007; }
long long q1(long long x) {
if (x < 0) return 0;
if (x < p) return (x + 1) * (x + 2) / 2 % 1000000007;
return ((p + 1) * p / 2 + (p - 1 + p + p - 1 - x) * (x - p + 1) / 2) %
1000000007;
}
long long qu(long long l, long long r) {
l = max(l, 0ll);
r = min(r, p * 2 - 1);
if (l > r) return 0;
return (q1(r) - q1(l - 1) + 1000000007) % 1000000007;
}
int main() {
cin >> p >> m;
cin >> s;
int l = s.length();
for (int i = 1; i <= l; i++) b[i] = s[l - i] - '0';
while (l > 0) {
long long su = 0;
for (int i = l; i >= 1; i--) {
su = su * 10 + b[i];
b[i] = su / p;
su %= p;
}
a[++n] = su;
while (b[l] == 0 && l > 0) l--;
}
if (m >= n) {
cout << "0" << endl;
return 0;
}
dp[0][1][0][0] = 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= n - i; j++) {
for (int k = 0; k <= 1; k++) {
for (int l = 0; l <= 1; l++) {
add(dp[j + l][0][l][1],
dp[j][0][k][0] * qu(0 + k * p - l, p - 1 + k * p - l));
add(dp[j + l][0][l][1],
dp[j][1][k][0] * qu(0 + k * p - l, a[i] - 1 + k * p - l));
add(dp[j + l][1][l][1],
dp[j][1][k][0] * qu(a[i] + k * p - l, a[i] + k * p - l));
}
}
}
for (int j = 0; j <= n; j++)
for (int k = 0; k <= 1; k++)
for (int l = 0; l <= 1; l++)
dp[j][k][l][0] = dp[j][k][l][1], dp[j][k][l][1] = 0;
}
for (int j = m; j <= n; j++) add(ans, dp[j][0][0][0] + dp[j][1][0][0]);
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int x[100][2];
int y[100][2];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i][0] >> y[i][0] >> x[i][1] >> y[i][1];
if (x[i][0] > x[i][1]) {
swap(x[i][0], x[i][1]);
}
if (y[i][0] > y[i][1]) {
swap(y[i][0], y[i][1]);
}
}
int h;
for (h = 0; h <= n; h++) {
double p = 0;
double q = 0;
double w = 0;
bool ok = true;
for (int i = h - 1; i >= 0; i--) {
double d = x[i][1] - x[i][0];
d = d * d * d;
p += d * (x[i][1] + x[i][0]);
q += d * (y[i][1] + y[i][0]);
w += 2 * d;
ok &= w * x[i][0] <= p && p <= w * x[i][1] && w * y[i][0] <= q &&
q <= w * y[i][1];
if (i > 0) {
ok &= w * x[i - 1][0] <= p && p <= w * x[i - 1][1] &&
w * y[i - 1][0] <= q && q <= w * y[i - 1][1];
}
}
if (!ok) {
break;
}
}
cout << h - 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long N = 1e3 + 10;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long eps = 1e-9;
const char spc = 29;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
using namespace std;
long long n;
long long res[N][N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n < 3) {
cout << -1 << "\n";
return 0;
}
if (n & 1) {
for (long long i = 0; i < n - 3; ++i)
for (long long j = 0; j < n; ++j)
res[i][j] = i * n + ((i & 1) ? (n - j) : (j + 1));
long long offset = n * (n - 3);
for (long long j = 0; j < n - 3; ++j)
for (long long i = 3; i > 0; --i)
res[n - i][j] = offset + (j * 3) + ((j & 1) ? i : (3 - i + 1));
offset = n * n - 9ll;
vector<vector<long long>> ans3 = {{1, 2, 4}, {5, 3, 8}, {9, 6, 7}};
for (long long i = 0; i < 3; ++i)
for (long long j = 0; j < 3; ++j)
res[n - 3 + i][n - 3 + j] = offset + ans3[i][j];
} else {
for (long long i = 0; i < n - 3; ++i)
for (long long j = 0; j < n; ++j)
res[i][j] = i * n + ((i & 1) ? (j + 1) : (n - j));
long long offset = n * (n - 3);
for (long long j = 0; j < n - 3; ++j)
for (long long i = 3; i > 0; --i)
res[n - i][j] = offset + (j * 3) + ((j & 1) ? i : (3 - i + 1));
offset = n * n - 9ll;
vector<vector<long long>> ans3 = {{9, 6, 7}, {5, 3, 8}, {1, 2, 4}};
for (long long i = 0; i < 3; ++i)
for (long long j = 0; j < 3; ++j)
res[n - 3 + i][n - 3 + j] = offset + ans3[i][j];
}
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < n; ++j) cout << res[i][j] << " ";
cout << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
int main(void) {
int n, m, i, j, k, cnt, flag;
char arr[101][101];
char r[101][101], c[101][101];
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", arr[i]);
for (i = 0; i < n; i++) {
cnt = 0;
for (j = 0; j < m - 1; j++) {
for (k = j + 1; k < m; k++) {
if (arr[i][j] == arr[i][k]) {
r[i][cnt++] = arr[i][j];
break;
}
}
}
r[i][cnt] = '\0';
}
for (i = 0; i < m; i++) {
cnt = 0;
for (j = 0; j < n - 1; j++) {
for (k = j + 1; k < n; k++) {
if (arr[j][i] == arr[k][i]) {
c[i][cnt++] = arr[j][i];
break;
}
}
}
c[i][cnt] = '\0';
}
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
flag = 1;
for (k = 0; k < strlen(r[i]); k++)
if (arr[i][j] == r[i][k]) {
flag = -1;
break;
}
if (flag == 1)
for (k = 0; k < strlen(c[j]); k++)
if (arr[i][j] == c[j][k]) {
flag = -1;
break;
}
if (flag == 1) printf("%c", arr[i][j]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, T;
int t[100];
while (1 == scanf("%d", &N)) {
for (int i = 0; i < N; i++) {
scanf("%d", &t[i]);
}
scanf("%d", &T);
sort(t, t + N);
int result, len;
result = 0;
for (int i = 0; i < N; i++) {
len = 1;
for (int j = i + 1; j < N; j++) {
if (t[j] - t[i] <= T) len++;
}
result = max(result, len);
}
printf("%d\n", result);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int cnt[100100], tcnt[100100];
int u[100100], v[100100];
int* g[100100];
int a[100100];
int niz[100100];
int rez[100100];
int q[1000100];
int main() {
int i, j, x, y, n, m;
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d %d", u + i, v + i);
cnt[u[i]]++;
cnt[v[i]]++;
}
for (i = 1; i <= n; i++)
g[i] = (int*)malloc(sizeof(int) * (cnt[i] + 1)), tcnt[i] = cnt[i];
for (i = 1; i <= m; i++) {
x = u[i];
y = v[i];
g[x][tcnt[x]--] = y;
g[y][tcnt[y]--] = x;
}
int p = 1, k = 1;
for (i = 1; i <= n; i++) {
scanf("%d", a + i);
if (!a[i]) q[k++] = i;
}
int sol = 0;
while (p != k) {
x = q[p];
if (a[x] != niz[x]) {
p++;
continue;
}
rez[++sol] = x;
niz[x]++;
for (i = 1; i <= cnt[x]; i++) {
j = g[x][i];
niz[j]++;
if (niz[j] == a[j]) q[k++] = j;
}
p++;
}
printf("%d\n", sol);
if (sol) {
for (i = 1; i < sol; i++) printf("%d ", rez[i]);
printf("%d\n", rez[sol]);
}
for (i = 1; i <= n; i++) free(g[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
void get(int *a, int n) {
if (n == 1)
a[0] = 1;
else if (n == 2) {
a[0] = 3;
a[1] = 4;
} else {
a[0] = n - 2;
for (int i = 1; i < n; i++) a[i] = 2;
}
}
int a[105], b[105];
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cin >> n >> m;
get(a, n);
get(b, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << a[i] * b[j] << " ";
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
bool upmin(int &a, const int &b) { return a > b ? a = b, 1 : 0; }
const int INF = ~0U >> 3, MAX_N = 100005, MAX_K = 505;
int fa[MAX_N];
int getfa(int v) { return fa[v] == v ? fa[v] : fa[v] = getfa(fa[v]); }
int idx[MAX_N], c[MAX_K];
int d[MAX_K][MAX_K];
int n, m, k;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; ++i)
for (int j = 1; j <= k; ++j) d[i][j] = i == j ? 0 : INF;
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= k; ++i) {
scanf("%d", &c[i]);
c[i] += c[i - 1];
for (int j = c[i - 1] + 1; j <= c[i]; ++j) idx[j] = i;
}
for (int i = 1; i <= m; ++i) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
if (w == 0) fa[getfa(x)] = getfa(y);
upmin(d[idx[x]][idx[y]], w);
upmin(d[idx[y]][idx[x]], w);
}
for (int i = 1; i <= k; ++i) {
int tp = getfa(c[i - 1] + 1);
for (int j = c[i - 1] + 1; j <= c[i]; ++j) {
if (getfa(j) != tp) {
printf("No\n");
exit(0);
}
}
}
for (int K = 1; K <= k; ++K)
for (int i = 1; i <= k; ++i)
for (int j = 1; j <= k; ++j) upmin(d[i][j], d[i][K] + d[K][j]);
printf("Yes\n");
for (int i = 1; i <= k; ++i)
for (int j = 1; j <= k; ++j)
printf("%d%c", d[i][j] == INF ? -1 : d[i][j], j == k ? '\n' : ' ');
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> ms;
map<string, int>::iterator it;
vector<pair<string, int> > x;
bool srt(pair<string, int> a, pair<string, int> b) {
return a.second > b.second;
}
void solve() {
int n, m, mn = 0, mx = 0;
string s;
vector<int> v;
scanf("%i%i", &n, &m);
v.resize(n);
for (int i = 0; i < n; i++) {
scanf("%i", &v[i]);
}
for (int i = 0; i < m; i++) {
cin >> s;
ms[s]++;
}
for (it = ms.begin(); it != ms.end(); it++)
x.push_back(make_pair(it->first, it->second));
sort(x.begin(), x.end(), srt);
sort(v.begin(), v.end());
for (int i = 0; i < x.size(); i++) {
mn += x[i].second * v[i];
}
reverse(v.begin(), v.end());
for (int i = 0; i < x.size(); i++) {
mx += x[i].second * v[i];
}
printf("%i %i\n", mn, mx);
}
int main() { solve(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 20;
int n, a[maxn], b[maxn], dp[maxn];
int pow2(int x) {
int f = 1;
for (int i = 0; i < x; i++) {
f *= 2;
}
return f;
}
int logarithm(int n, int p) {
int ans = 1, cp = p;
p += 1;
while (p < n) {
p -= pow2(ans - 1);
p += pow2(ans);
ans++;
}
return cp + pow2(ans - 2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = logarithm(n, i);
}
dp[0] = a[0];
a[b[0]] += a[0];
a[0] = 0;
for (int i = 1; i < n - 1; i++) {
dp[i] += a[i] + dp[i - 1];
a[b[i]] += a[i];
a[i] = 0;
}
for (int i = 0; i < n - 1; i++) {
cout << dp[i] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int cnt = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2 * m; j += 2) {
int x, y;
cin >> x >> y;
if (x || y) cnt++;
}
}
cout << cnt << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[30] = {0};
int n;
cin >> a[0] >> a[1] >> n;
;
for (int i = 2; i <= 25; i++) a[i] = a[i - 1] + a[i - 2];
cout << a[n];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
cout << n + 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 4 * atan(1);
int T, N;
long long X[100013], Y[100013], Z[100013];
long long ansx, ansy, ansz;
inline bool is(long long x, int p) { return (((x % 2) + 2) % 2) == p; }
bool go(long long d) {
long long xmi = -8.1e18, xma = 8.1e18, ymi = -8.1e18, yma = 8.1e18,
zmi = -8.1e18, zma = 8.1e18, smi = -8.1e18, sma = 8.1e18;
for (int i = 0; i < N; i++) {
xmi = max(xmi, Y[i] + Z[i] - X[i] - d);
xma = min(xma, Y[i] + Z[i] - X[i] + d);
ymi = max(ymi, -Y[i] + Z[i] + X[i] - d);
yma = min(yma, -Y[i] + Z[i] + X[i] + d);
zmi = max(zmi, Y[i] - Z[i] + X[i] - d);
zma = min(zma, Y[i] - Z[i] + X[i] + d);
smi = max(smi, Y[i] + Z[i] + X[i] - d);
sma = min(sma, Y[i] + Z[i] + X[i] + d);
}
for (int p = 0; p < 2; p++) {
long long xmi2 = xmi + is(xmi, !p);
long long ymi2 = ymi + is(ymi, !p);
long long zmi2 = zmi + is(zmi, !p);
long long xma2 = xma - is(xma, !p);
long long yma2 = yma - is(yma, !p);
long long zma2 = zma - is(zma, !p);
long long smi2 = smi + is(smi, !p);
long long sma2 = sma - is(sma, !p);
if (smi2 > sma2 || xmi2 > xma2 || ymi2 > yma2 || zmi2 > zma2) continue;
long long qmi = xmi2 + ymi2 + zmi2, qma = xma2 + yma2 + zma2;
if (qmi <= sma2 && qma >= smi2) {
if (xma2 + ymi2 + zmi2 < smi2) {
if (xma2 + yma2 + zmi2 < smi2) {
ansx = xma2;
ansy = yma2;
ansz = smi2 - ansx - ansy;
} else {
ansx = xma2;
ansz = zmi2;
ansy = smi2 - ansx - ansz;
}
} else {
ansy = ymi2;
ansz = zmi2;
ansx = max(xmi2, smi2 - ansy - ansz);
}
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> T;
while (T--) {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i] >> Z[i];
}
long long lo = 0;
long long hi = 3.1e18;
while (lo != hi) {
long long mid = (lo + hi) / 2;
if (go(mid)) {
hi = mid;
} else {
lo = mid + 1;
}
}
go(lo);
cout << (ansy + ansz) / 2 << ' ' << (ansx + ansz) / 2 << ' '
<< (ansx + ansy) / 2 << '\n';
}
cout.flush();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, b(3);
cin >> n;
while (n % b == 0) {
b *= 3;
}
cout << n / b + 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
char lesha[maxn][maxn];
char pep[15][maxn][15];
int pepl[15];
int n, m;
int pos[6][15];
int lu[6];
void dfs(int &x, int s, int e) {
int i, j, k;
if (s == e) {
k = 0;
for (i = 0; i < e; i++)
for (j = i + 1; j < e; j++)
if (lu[j] < lu[i]) k++;
if (k < x) x = k;
return;
}
for (i = 1; i <= pos[s][0]; i++) {
lu[s] = pos[s][i];
dfs(x, s + 1, e);
}
}
int main() {
int archive, p, x;
int i, j, k, tmp, l, lk;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%s", lesha[i]);
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d", &pepl[i]);
for (j = 0; j < pepl[i]; j++) scanf("%s", pep[i][j]);
}
p = -1;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < pepl[i]; k++)
if (strcmp(pep[i][k], lesha[j]) == 0) break;
if (k < pepl[i])
continue;
else
break;
}
if (j < n) continue;
for (j = 0; j < n; j++) {
pos[j][0] = 0;
for (k = 0; k < pepl[i]; k++)
if (strcmp(pep[i][k], lesha[j]) == 0) {
pos[j][0]++;
pos[j][pos[j][0]] = k;
}
}
x = n * n;
dfs(x, 0, n);
tmp = n * (n - 1) / 2 - x + 1;
if (tmp > p) {
p = tmp;
archive = i + 1;
}
}
if (p == -1)
printf("Brand new problem!\n");
else {
printf("%d\n", archive);
printf("[:");
for (i = 0; i < p; i++) printf("|");
printf(":]\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1100000;
int n, k, l, a[N];
char S[N];
struct aa {
int x, y;
double v;
} dp[N];
aa add_x(aa a, int b) {
a.x += b;
a.v += b;
return a;
}
aa add_y(aa a, double t) {
a.y++;
a.v += t;
return a;
}
aa min(aa x, aa y) {
if (x.v < y.v)
return x;
else
return y;
}
aa compute(double t) {
for (int i = 1; i <= n; i++) {
if (i < l) {
dp[i] = add_x(dp[i - 1], a[i]);
} else {
dp[i] = min(add_x(dp[i - 1], a[i]), add_y(dp[i - l], t));
}
}
return dp[n];
}
int solve() {
double l = 0, r = 1e9;
for (int i = 1; i <= 70; i++) {
double mid = (l + r) / 2;
auto ans = compute(mid);
if (ans.y <= k)
r = mid;
else
l = mid;
}
auto ans = compute((l + r) / 2);
return int(round(ans.v - (l + r) / 2 * k));
}
int main() {
scanf("%d%d%d", &n, &k, &l);
if (1LL * k * l >= n) {
printf("0\n");
return 0;
}
scanf("%s", S + 1);
for (int i = 1; i <= n; i++) {
if ('a' <= S[i] && S[i] <= 'z') {
a[i] = 0;
} else {
a[i] = 1;
}
}
int ans = solve();
for (int i = 1; i <= n; i++) {
if ('a' <= S[i] && S[i] <= 'z') {
a[i] = 1;
} else {
a[i] = 0;
}
}
ans = min(ans, solve());
printf("%d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
using namespace std;
const int inf = 1000000000;
int n, m, y, Y;
int x[111111], X[111111];
int d[111111][2];
vector<int> v[111111];
int main() {
cin >> n >> m >> y >> Y;
for (int i(0); i < (n); i++) scanf("%d", x + i);
for (int i(0); i < (m); i++) scanf("%d", X + i);
for (int i(0); i < (n); i++) d[i][0] = d[i][1] = inf;
for (int i(0); i < (n); i++) {
int pos = lower_bound(X, X + m, x[i]) - X;
if (pos >= m)
pos--;
else {
if (pos >= 1) {
if (X[pos] - x[i] > x[i] - X[pos - 1]) pos--;
}
}
if (pos >= 1 && X[pos] - x[i] == x[i] - X[pos - 1]) {
v[i].push_back(pos - 1);
v[i].push_back(pos);
pos--;
if (i == 0)
d[0][0] = d[0][1] = 0;
else {
d[i][1] = min(d[i - 1][0], d[i - 1][1]);
if (v[i - 1].size() == 2) {
if (v[i - 1].back() == pos)
d[i][0] =
min(d[i - 1][0],
d[i - 1][1] + (x[i - 1] + x[i] != X[pos] * 2 ? 1 : 0));
else
d[i][0] = min(d[i - 1][0], d[i - 1][1]);
} else {
if (v[i - 1][0] == pos)
d[i][0] = d[i - 1][0] + (x[i - 1] + x[i] != X[pos] * 2 ? 1 : 0);
else
d[i][0] = d[i - 1][0];
}
}
} else {
v[i].push_back(pos);
if (i == 0) {
d[0][0] = 0;
} else {
if (v[i - 1].size() == 2) {
if (v[i - 1].back() == pos)
d[i][0] =
min(d[i - 1][0],
d[i - 1][1] + (x[i - 1] + x[i] != X[pos] * 2 ? 1 : 0));
else
d[i][0] = min(d[i - 1][0], d[i - 1][1]);
} else {
if (v[i - 1][0] == pos)
d[i][0] = d[i - 1][0] + (x[i - 1] + x[i] != X[pos] * 2 ? 1 : 0);
else
d[i][0] = d[i - 1][0];
}
}
}
}
cout << min(d[n - 1][0], d[n - 1][1]) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, x, sum = 0;
cin >> n;
long long t_fr = n + 1;
while (n--) {
cin >> x;
sum += x;
}
long long ct = 0;
for (long long(i) = 1; (i) <= (5); (i)++) {
if (((sum + i) % t_fr) != 1) ct++;
}
cout << ct;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void chkmax(int &a, int b) {
if (a < b) a = b;
}
inline void chkmin(int &a, int b) {
if (a > b) a = b;
}
inline int read() {
int a = 0, fh = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') fh = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
a = a * 10 + c - 48;
c = getchar();
}
return a * fh;
}
int T, n, m, rt;
int ban[1005], siz[1005], w[1005];
vector<int> edge[1005];
void getrt(int x, int fa) {
siz[x] = 1;
w[x] = 0;
for (int i = 0; i < edge[x].size(); ++i)
if (edge[x][i] != fa && !ban[edge[x][i]]) {
getrt(edge[x][i], x);
if (siz[w[x]] < siz[edge[x][i]]) w[x] = edge[x][i];
siz[x] += siz[edge[x][i]];
}
if (!rt || max(siz[w[rt]], n - siz[rt]) > max(siz[w[x]], n - siz[x])) rt = x;
}
void dfs(int x, int fa) {
n++;
for (int i = 0; i < edge[x].size(); ++i)
if (!ban[edge[x][i]] && edge[x][i] != fa) dfs(edge[x][i], x);
}
int main() {
n = read();
int m = read();
int ans = 0;
for (int i = 1; i <= n; ++i) ans += (i - 1) / 2;
if (ans < m) {
puts("-1");
return 0;
}
int now = 0, lst = 0;
for (int i = 1; i <= n; ++i) {
if (now + (i - 1) / 2 <= m) {
now += (i - 1) / 2;
printf("%d ", i);
} else {
int ned = m - now;
int p = i - ned * 2;
now = m;
printf("%d ", i - 1 + p);
for (int j = i + 1; j <= n; ++j) printf("%d ", j * 10000 + 1);
return 0;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, test;
t = 1;
for (test = 1; test <= t; test++) {
long long i, j, n, m, k, q, sum, maxm, minm, counter, flag;
long long answer;
long long c;
cin >> n >> c;
long long dp[n + 1][2];
long long a[n], b[n];
for (i = 1; i <= n - 1; i++) {
cin >> a[i];
}
for (i = 1; i <= n - 1; i++) {
cin >> b[i];
}
dp[1][0] = 0;
dp[1][1] = c;
for (i = 2; i <= n; i++) {
dp[i][0] = min(dp[i - 1][0] + a[i - 1], dp[i - 1][1] + a[i - 1]);
dp[i][1] = min(dp[i - 1][0] + b[i - 1] + c, dp[i - 1][1] + b[i - 1]);
}
for (i = 1; i <= n; i++) {
cout << min(dp[i][0], dp[i][1]) << " ";
}
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long inf = LLONG_MAX;
long double pi = 3.1415926536;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tt = 1;
cin >> tt;
while (tt--) {
long long n, x = 0, m = 0, y = 0, k = inf;
string s;
cin >> s;
vector<pair<long long, long long> > v;
pair<long long, long long> p = {0, 0}, fin = {0, 0};
map<pair<pair<long long, long long>, pair<long long, long long> >,
long long>
vis;
for (long long i = 0; i < s.length(); i++) {
if (s[i] == 'N') fin.second++;
if (s[i] == 'S') fin.second--;
if (s[i] == 'E') fin.first++;
if (s[i] == 'W') fin.first--;
vis[{p, fin}]++;
vis[{fin, p}]++;
p = fin;
}
long long ans = 0;
for (auto i : vis) {
if (i.second == 1) {
ans += 5;
} else {
ans += 5;
ans += (i.second - 1);
}
}
cout << ans / 2 << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct triple {
int x, y, dis;
triple() {}
triple(int X, int Y, int DIS) { x = X, y = Y, dis = DIS; }
bool operator<(triple t) const { return dis > t.dis; }
} P[3600];
int cnt;
int low, x, ans, n;
int choice[16];
int record[16];
void dfs() {
int i, j;
if (x == n) {
int sum = 0;
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++) {
triple &u = P[choice[i]];
triple &v = P[choice[j]];
sum += (u.x - v.x) * (u.x - v.x) + (u.y - v.y) * (u.y - v.y);
}
if (sum > ans) {
ans = sum;
memcpy(record, choice, sizeof(choice));
}
return;
}
for (i = low; i < cnt; i++) {
int tmp = low;
low = i;
choice[x++] = i;
dfs();
low = tmp;
x--;
}
}
int main() {
int r, i, j;
while (~scanf("%d%d", &n, &r)) {
cnt = 0;
for (i = -r; i <= r; i++)
for (j = -r; j <= r; j++) {
int dis = i * i + j * j;
if (dis <= r * r) P[cnt++] = triple(i, j, dis);
}
sort(P, P + cnt);
cnt = min(cnt, 30 - 2 * n);
x = ans = 0;
dfs();
printf("%d\n", ans);
for (i = 0; i < n; i++) {
triple &u = P[record[i]];
printf("%d %d\n", u.x, u.y);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int T[1010], L[1010], R[1010];
int up[1010];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N >> M;
for (i = 0; i < (M); i++) {
cin >> T[i] >> L[i] >> R[i];
L[i]--, R[i]--;
if (T[i] == 1) {
for (x = L[i]; x < R[i]; x++) up[x] = 1;
}
}
for (i = 0; i < (M); i++)
if (T[i] == 0) {
int ok = 0;
for (x = L[i]; x < R[i]; x++)
if (up[x] == 0) ok = 1;
if (ok == 0) return (void)printf("NO\n");
}
int cur = 1010;
cout << "YES" << endl;
for (i = 0; i < (N); i++) {
cout << cur << " ";
if (up[i])
cur++;
else
cur--;
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string a, b;
cin >> n >> a >> b;
if (b == "week") {
if (n == 5 || n == 6)
cout << "53" << endl;
else
cout << "52" << endl;
} else {
if (n == 31)
cout << "7" << endl;
else if (n == 30)
cout << "11" << endl;
else
cout << "12" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e16, mod = 1e9 + 7;
long long arr[400004];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
long long mi = inf;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
mi = min(mi, arr[i]);
arr[n + i] = arr[i];
}
long long ans = mi * n;
for (int i = 1; i <= 2 * n; i++) arr[i] -= mi;
long long cnt = 0;
long long ma = -inf;
for (int i = 1; i <= 2 * n; i++) {
if (arr[i] != 0)
cnt++;
else {
ma = max(ma, cnt);
cnt = 0;
}
}
cout << ans + ma;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
pair<char, int> a[123];
int bitCount(int s) {
if (s == 0) return 0;
return (s & 1) + bitCount(s >> 1);
}
int getA(char a) {
switch (a) {
case 'R':
return 0;
case 'G':
return 1;
case 'B':
return 2;
case 'Y':
return 3;
case 'W':
return 4;
default:
return -1;
}
}
int getA(int a) { return a - 1; }
int main() {
int n;
cin >> n;
set<pair<char, int> > st;
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
st.insert(a[i]);
}
n = 0;
for (set<pair<char, int> >::iterator it = st.begin(); it != st.end(); ++it)
a[n++] = *it;
int answer = 10;
for (int i = 0; i < 1024; ++i) {
int count = bitCount(i);
if (answer <= count) continue;
int f = (i & 31);
int s = (i >> 5);
bool ok = 1;
for (int j = 0; j < n; ++j)
for (int k = 0; k < j; ++k)
if (a[j].first != a[k].first || a[j].second != a[k].second)
if ((f & (1 << getA(a[j].first))) == (f & (1 << getA(a[k].first))))
if ((s & (1 << getA(a[j].second))) ==
(s & (1 << getA(a[k].second))))
ok = 0;
if (ok) answer = count;
}
cout << answer;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
using namespace std;
long long ans = 1;
long long n, k;
long long a[200];
bool check(long long x) {
long long sum = 0;
for (int i = 1; i <= n; ++i) {
sum += ((a[i] - 1) / x + 1) * x - a[i];
}
return sum <= k;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
long long sum = k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum += a[i];
}
for (long long i = 1; i * i <= sum; ++i) {
if (i > ans) {
if (check(i)) {
ans = i;
}
}
if (sum / i > ans) {
if (check(sum / i)) {
ans = sum / i;
}
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55, M = 1e9 + 7;
long long dp[N], k;
int n;
long long calc(int in) {
if (in >= n) return dp[in] = 1;
long long &ret = dp[in];
if (ret != -1) return ret;
ret = 0;
ret = calc(in + 1);
ret += calc(in + 2);
return ret;
}
vector<int> v;
void print(int in, long long k) {
if (in > n) return;
if (calc(in + 1) >= k) {
v.push_back(in);
print(in + 1, k);
return;
}
v.push_back(in + 1);
v.push_back(in);
print(in + 2, k - calc(in + 1));
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> k;
print(1, k);
for (int i = 0; i < v.size(); i++) {
printf("%d ", v[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
string w, r[3];
int dp[251][251][251], next_oc[100002][26];
void compute(int a, int b, int c) {
int &val = dp[a][b][c];
val = n;
if (a) val = min(val, next_oc[dp[a - 1][b][c] + 1][r[0][a - 1] - 'a']);
if (b) val = min(val, next_oc[dp[a][b - 1][c] + 1][r[1][b - 1] - 'a']);
if (c) val = min(val, next_oc[dp[a][b][c - 1] + 1][r[2][c - 1] - 'a']);
}
int main() {
cin >> n >> q >> w;
for (int i = 0; i < 26; i++) next_oc[n][i] = next_oc[n + 1][i] = n;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < 26; j++)
next_oc[i][j] = w[i] == 'a' + j ? i : next_oc[i + 1][j];
dp[0][0][0] = -1;
int mx[3], mn[3];
while (q--) {
int id;
char c, flag;
cin >> flag >> id;
id--;
if (flag == '+') {
cin >> c;
r[id] += c;
for (int i = 0; i < 3; i++) mx[i] = r[i].size();
for (int i = 0; i < 3; i++) mn[i] = id == i ? mx[i] : 0;
for (int i = mn[0]; i <= mx[0]; i++)
for (int j = mn[1]; j <= mx[1]; j++)
for (int k = mn[2]; k <= mx[2]; k++) compute(i, j, k);
} else {
r[id].pop_back();
}
if (dp[r[0].size()][r[1].size()][r[2].size()] < n)
puts("Yes");
else
puts("No");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 21, bit = 21;
int a[N], counter[N + 5];
void upd(int mask, int k) {
if (counter[mask] < 2) {
counter[mask]++;
for (; k < bit; k++) {
if (mask & (1 << k)) upd(mask ^ (1 << k), k + 1);
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; ~i; i--) {
if (counter[0] >= 2) {
int mask = 0;
for (int j = bit - 1; ~j; j--) {
if (a[i] & (1 << j)) continue;
if (counter[mask | (1 << j)] > 1) mask |= (1 << j);
}
ans = max(ans, (a[i] | mask));
}
upd(a[i], 0);
}
cout << ans << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(2 * n);
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i < 2 * n; i++) {
int cur = a[i];
if (cur == -1) {
continue;
}
int cnt = 1;
for (int j = i + 1; j < 2 * n; j++) {
if (a[j] == -1) {
cnt++;
continue;
}
if (a[j] == cur) {
ans += j - i - cnt;
a[j] = -1;
break;
}
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, d, mod, ans, tr[15];
int f[1005], inv[15];
int g[15][1005];
int main() {
scanf("%d%d%d", &n, &d, &mod);
if (n == 1) return puts("1"), 0;
for (int i = (int)(0); i <= (int)(d); i++) g[i][i] = 1;
f[1] = inv[0] = inv[1] = 1;
for (int i = (int)(2); i <= (int)(d); i++)
inv[i] = 1ll * inv[mod % i] * (mod - mod / i) % mod;
for (int i = (int)(2); i <= (int)(n / 2); i++) {
f[i] = g[d - 1][i - 1];
tr[0] = 1;
for (int j = (int)(1); j <= (int)(d); j++)
tr[j] = 1ll * tr[j - 1] * inv[j] % mod * (f[i] + j - 1) % mod;
for (int j = (int)(d); j >= (int)(0); j--)
for (int k = (int)(1); k <= (int)(d - j); k++)
for (int l = (int)(0); l <= (int)(n - k * i); l++)
g[j + k][l + k * i] =
(g[j + k][l + k * i] + 1ll * g[j][l] * tr[k]) % mod;
if (i == (n - 1) / 2) ans = g[d][n - 1];
}
if (n % 2 == 0) ans = (ans + 1ll * f[n / 2] * (f[n / 2] + 1) / 2) % mod;
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rnd(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 150000;
const int MAXLG = 17;
const int MAXPATH = 150000;
const int MAXSNODES = MAXN * (MAXLG + 2);
int n, npath, need;
vector<int> adj[MAXN];
int path[MAXPATH][2];
int par[MAXN], dep[MAXN], sz[MAXN], heavy[MAXN];
int up[MAXN][MAXLG + 1];
int lid[MAXN], rid[MAXN], nid;
vector<int> bylca[MAXN];
void dfsinit(int at) {
dep[at] = par[at] == -1 ? 0 : dep[par[at]] + 1;
sz[at] = 1;
heavy[at] = -1;
up[at][0] = par[at] == -1 ? at : par[at];
for (int k = (0); k < (MAXLG); ++k) up[at][k + 1] = up[up[at][k]][k];
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at]) continue;
par[to] = at;
dfsinit(to);
sz[at] += sz[to];
if (heavy[at] == -1 || sz[to] > sz[heavy[at]]) heavy[at] = to;
}
rid[at] = nid - 1;
}
void dfsid(int at) {
lid[at] = nid++;
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at] || to == heavy[at]) continue;
dfsid(to);
}
if (heavy[at] != -1) dfsid(heavy[at]);
rid[at] = nid - 1;
}
int calcup(int a, int cnt) {
for (int k = (0); k <= (MAXLG); ++k)
if (cnt & (1 << k)) a = up[a][k];
return a;
}
int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
a = calcup(a, dep[a] - dep[b]);
if (a == b) return a;
for (int k = MAXLG; k >= 0; --k)
if (up[a][k] != up[b][k]) a = up[a][k], b = up[b][k];
return par[a];
}
bool isdesc(int a, int b) { return lid[b] <= lid[a] && rid[a] <= rid[b]; }
long long ans;
int bit[MAXN + 1];
int bget(int idx) {
++idx;
int ret = 0;
while (idx > 0) {
ret += bit[idx];
idx -= idx & -idx;
}
return ret;
}
void bmod(int idx, int by) {
++idx;
while (idx <= n) {
bit[idx] += by;
idx += idx & -idx;
}
}
int bget(int lidx, int ridx) { return bget(ridx) - bget(lidx - 1); }
void dfs1(int at) {
for (int i = (0); i < (2); ++i) {
for (int _ = (0); _ < (((int)(bylca[at]).size())); ++_) {
int id = bylca[at][_];
int to = path[id][i];
if (dep[to] - dep[at] < need) continue;
to = calcup(to, dep[to] - dep[at] - need);
ans += bget(lid[to], rid[to]);
}
for (int _ = (0); _ < (((int)(bylca[at]).size())); ++_) {
int id = bylca[at][_];
int to = path[id][i];
bmod(lid[to], +1);
}
}
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at]) continue;
dfs1(to);
}
}
struct SNode {
int l, r, sum;
};
vector<int> byfst[MAXN];
int sndset[MAXN];
SNode snodes[MAXSNODES];
int nsnodes;
int smake() {
assert(nsnodes < MAXSNODES);
SNode node;
node.l = node.r = -1;
node.sum = 0;
snodes[nsnodes++] = node;
return nsnodes - 1;
}
void spull(int x) {
snodes[x].sum = 0;
if (snodes[x].l != -1) snodes[x].sum += snodes[snodes[x].l].sum;
if (snodes[x].r != -1) snodes[x].sum += snodes[snodes[x].r].sum;
}
void smod(int& x, int l, int r, int IDX, int BY) {
if (x == -1) x = smake();
if (l == r) {
snodes[x].sum += BY;
} else {
int m = l + (r - l) / 2;
if (IDX <= m)
smod(snodes[x].l, l, m, IDX, BY);
else
smod(snodes[x].r, m + 1, r, IDX, BY);
spull(x);
}
}
int sget(int x, int l, int r, int L, int R) {
if (x == -1) return 0;
if (L <= l && r <= R) {
return snodes[x].sum;
} else {
int m = l + (r - l) / 2;
int ret = 0;
if (L <= m) ret += sget(snodes[x].l, l, m, L, R);
if (m + 1 <= R) ret += sget(snodes[x].r, m + 1, r, L, R);
return ret;
}
}
void smerge(int& x, int y) {
if (y == -1)
return;
else if (x == -1) {
x = y;
return;
}
smerge(snodes[x].l, snodes[y].l);
smerge(snodes[x].r, snodes[y].r);
if (snodes[x].l == -1 && snodes[x].r == -1)
snodes[x].sum += snodes[y].sum;
else
spull(x);
}
void calc(int id, int x, int at, int root) {
int a = path[id][0], b = path[id][1];
int extra = max(0, need - (dep[at] - dep[root]));
if (dep[b] - dep[root] >= extra) {
int to = extra == 0 ? root : calcup(b, dep[b] - dep[root] - extra);
int cnt = sget(sndset[x], 0, n - 1, lid[to], rid[to]);
ans += cnt;
}
}
int merge(int x, int y, int at, int root) {
if (((int)(byfst[x]).size()) < ((int)(byfst[y]).size())) swap(x, y);
for (int _ = (0); _ < (((int)(byfst[y]).size())); ++_) {
int id = byfst[y][_];
calc(id, x, at, root);
byfst[x].push_back(id);
}
smerge(sndset[x], sndset[y]);
byfst[y].clear();
sndset[y] = -1;
return x;
}
int dfs2(int at, int root) {
int ret = at;
for (int _ = (0); _ < (((int)(byfst[at]).size())); ++_) {
int id = byfst[at][_];
int a = path[id][0], b = path[id][1];
calc(id, ret, at, root);
smod(sndset[ret], 0, n - 1, lid[b], +1);
}
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par[at] || to == heavy[root]) continue;
int sub = dfs2(to, root);
ret = merge(ret, sub, at, root);
}
return ret;
}
long long solve() {
par[0] = -1;
dfsinit(0);
nid = 0;
dfsid(0);
for (int i = (0); i < (n); ++i) bylca[i].clear();
for (int i = (0); i < (npath); ++i) {
int &a = path[i][0], &b = path[i][1];
if (lid[a] > lid[b]) swap(a, b);
int c = lca(a, b);
bylca[c].push_back(i);
}
ans = 0;
for (int i = (0); i <= (n); ++i) bit[i] = 0;
dfs1(0);
nsnodes = 0;
for (int i = (0); i < (n); ++i) byfst[i].clear(), sndset[i] = -1;
for (int at = (0); at < (n); ++at) {
for (int _ = (0); _ < (((int)(bylca[at]).size())); ++_) {
int id = bylca[at][_];
int a = path[id][0], b = path[id][0];
if (heavy[at] != -1) assert(!isdesc(a, heavy[at]));
byfst[a].push_back(id);
}
int sub = dfs2(at, at);
assert(((int)(byfst[sub]).size()) == ((int)(bylca[at]).size()));
nsnodes = 0;
byfst[sub].clear();
sndset[sub] = -1;
}
return ans;
}
void run() {
scanf("%d%d%d", &n, &npath, &need);
for (int i = (0); i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b), adj[b].push_back(a);
}
for (int i = (0); i < (npath); ++i)
for (int j = (0); j < (2); ++j) scanf("%d", &path[i][j]), --path[i][j];
printf("%lld\n", solve());
}
long long solvestupid() {
par[0] = -1;
dfsinit(0);
long long ret = 0;
for (int i = (0); i < (npath); ++i)
for (int j = (i + 1); j < (npath); ++j) {
int ai = path[i][0], bi = path[i][1], ci = lca(ai, bi);
int aj = path[j][0], bj = path[j][1], cj = lca(aj, bj);
set<int> have;
while (ai != ci) have.insert(ai), ai = par[ai];
while (bi != ci) have.insert(bi), bi = par[bi];
int cnt = 0;
while (aj != cj) cnt += have.count(aj), aj = par[aj];
while (bj != cj) cnt += have.count(bj), bj = par[bj];
if (cnt >= need) ++ret;
}
return ret;
}
void stress() {
for (int rep = (0); rep < (1000000); ++rep) {
n = rnd() % (10 - 1) + 2;
npath = rnd() % 10 + 1;
need = rnd() % (n - 1) + 1;
vector<pair<int, int>> e;
vector<int> col(n);
for (int i = (0); i < (n); ++i) col[i] = i;
for (int i = (0); i < (n - 1); ++i)
while (true) {
int a = rnd() % n, b = rnd() % n;
if (col[a] == col[b]) continue;
int ocol = col[b];
for (int j = (0); j < (n); ++j)
if (col[j] == ocol) col[j] = col[a];
e.push_back(make_pair(a, b));
break;
}
for (int i = (0); i < (n); ++i) adj[i].clear();
for (int i = (0); i < (((int)(e).size())); ++i) {
int a = e[i].first, b = e[i].second;
adj[a].push_back(b), adj[b].push_back(a);
}
for (int i = (0); i < (npath); ++i)
path[i][0] = rnd() % n, path[i][1] = rnd() % n;
long long want = solvestupid();
long long have = solve();
if (have == want) {
if (rep % 1000 == 999) printf(".");
continue;
}
printf("err have=%lld want=%lld\n", have, want);
printf("%d %d %d\n", n, npath, need);
for (int i = (0); i < (((int)(e).size())); ++i)
printf("%d %d\n", e[i].first + 1, e[i].second + 1);
for (int i = (0); i < (npath); ++i)
printf("%d %d\n", path[i][0] + 1, path[i][1] + 1);
break;
}
}
int main() {
run();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
double k;
map<string, int> mp;
int main() {
scanf("%d%d%lf", &n, &m, &k);
for (int i = 1; i <= n; i++) {
string s;
double x;
cin >> s >> x;
x *= k;
if (x >= 100) mp[s] = (int)(x + 1e-6);
}
for (int i = 1; i <= m; i++) {
string s;
cin >> s;
if (mp.find(s) != mp.end()) continue;
mp[s] = 0;
}
cout << mp.size() << endl;
for (auto c : mp) {
cout << c.first << ' ' << c.second << endl;
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define fi first
#define se second
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define repi(i,a,b) for(int i=a;i>=b;i--)
#define vi vector<int>
#define vvi vector<vector<int> >
#define vll vector<long long int>
#define vvll vector<vector<long long> >
#define vb vector<bool>
#define pii pair<int,int>
#define tiii tuple<int,int,int>
#define mod 1000000007
#define mem1(x) memset(x,1,sizeof(x))
#define mem0(x) memset(x,0,sizeof(x))
#define memn1(x) memset(x,-1,sizeof(x))
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL)
#define inf 1e17+1
template<class x> x gcd(x a, x b) {return (b == 0) ? a : gcd(b, a % b);}
template<class x> x powerm(x a, x n) {if (n == 0)return 1; x b = powerm(a, n / 2) % mod; return (n & 1) ? ((b * b) % mod * a) % mod : (b * b) % mod;}
const int cnst = 7001;
void solve() {
int n;
cin >> n;
ll a[n + 1];
rep(i, 1, n) {
cin >> a[i];
}
ll ans = 0;
bool cnt[n + 2];
mem0(cnt);
rep(i, 2, n - 1) {
if ( (a[i] - a[i - 1]) * (a[i] - a[i + 1]) > 0 ) {
ans++;
cnt[i] = 1;
}
}
int m = 0;
rep(i, 1, n) {
vector<ll> tryy;
tryy.pb(a[i]);
tryy.pb(a[i] - 1);
tryy.pb(a[i] + 1);
if (i > 1) {
tryy.pb(a[i - 1]);
tryy.pb(a[i - 1] - 1);
tryy.pb(a[i - 1] + 1);
}
if (i < n) {
tryy.pb(a[i + 1]);
tryy.pb(a[i + 1] - 1);
tryy.pb(a[i + 1] + 1);
}
for (ll x : tryy) {
int tmp = cnt[i] + cnt[i - 1] + cnt[i + 1];
if ( i > 1 && i < n ) {
if ( (x - a[i - 1]) * (x - a[i + 1]) > 0 ) {
tmp--;
}
}
if (i > 2) {
if ( (a[i - 1] - a[i - 2]) * (a[i - 1] - x) > 0 ) {
tmp--;
}
}
if (i < n - 1) {
if ( (a[i + 1] - a[i + 2]) * (a[i + 1] - x) > 0 ) {
tmp--;
}
}
m = max(m, tmp);
}
}
cout << (ans - m) << endl;
}
int main() {
#ifndef ONLINE_JUDGE
//for reading input from input.txt
freopen("input.txt", "r", stdin);
//for writing output in output.txt
freopen("output.txt", "w", stdout);
#endif
int t = 1;
cin >> t;
while (t--) {
solve();
}
} | 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct nim_range {
long long lo;
long long hi;
int val;
};
int n;
long long p;
long long mod = (long long)1e9 + 7;
vector<nim_range> ranges;
long long sum[3] = {0, 0, 0};
nim_range nrange(long long lo, long long hi, int val) {
nim_range x;
x.lo = lo;
x.hi = hi;
x.val = val;
return x;
}
int join(int a, int b) {
if (a * b != 0) return 0;
if (a + b == 1) return 2;
return 1;
}
void add(nim_range nr) {
nim_range prev = ranges[ranges.size() - 1];
if (nr.val == prev.val) {
nr = nrange(prev.lo, nr.hi, nr.val);
ranges.pop_back();
}
ranges.push_back(nr);
}
void compute_nim() {
ranges.push_back(nrange(1, 2, 0));
ranges.push_back(nrange(3, 3, 1));
long long curval = 4;
int lo = 0;
int hi = 1;
long long until = 5;
while (curval <= p) {
add(nrange(curval, until - 1, join(ranges[lo].val, ranges[hi].val)));
curval = until;
if (curval / 3 > ranges[lo].hi) lo++;
if (curval - curval / 3 > ranges[hi].hi) hi++;
until = min(3 * ranges[lo].hi + 2, 3 * ranges[hi].hi / 2) + 1;
}
}
void compute_sum() {
for (int i = 0; i < ranges.size(); i++) {
long long lo = ranges[i].lo;
long long hi = min(ranges[i].hi, p);
if (hi < lo) break;
long long a = p + 1 - lo, b = p + 1 - hi;
sum[ranges[i].val] += (a - b + 1) * (a + b) / 2;
sum[ranges[i].val] %= mod;
}
}
long long compute_dp() {
long long state[4] = {1, 0, 0, 0};
for (int i = 1; i <= n; i++) {
long long nstate[4] = {0, 0, 0, 0};
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 4; k++) {
nstate[(j ^ k)] += state[k] * sum[j];
nstate[(j ^ k)] %= mod;
}
}
for (int j = 0; j < 4; j++) {
state[j] = nstate[j];
}
}
long long ans = 0;
for (int i = 1; i <= 3; i++) {
ans += state[i];
}
return ans % mod;
}
int main() {
scanf("%d %I64d", &n, &p);
p--;
compute_nim();
compute_sum();
printf("%I64d\n", compute_dp());
fflush(stdin);
getchar();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1 << 17, LOG = 17, INF = 0x3f3f3f3f;
vector<int> Vec[MAX];
vector<int> V[MAX], C[MAX];
int bitanlc[MAX], bitan[MAX];
int dub[MAX], disc[MAX], fin[MAX], vr = 1;
int koji[MAX];
int lca[MAX][LOG];
int n;
long long dp[MAX][2];
int zgrada[MAX];
void Dfs(int node, int prosli) {
dub[node] = dub[prosli] + 1;
koji[vr] = node;
disc[node] = vr++;
lca[node][0] = prosli;
for (int i = 1; i < LOG; i++) lca[node][i] = lca[lca[node][i - 1]][i - 1];
for (int i = 0; i < (int)V[node].size(); i++) {
int nn = V[node][i];
if (nn == prosli)
V[node].erase(V[node].begin() + i--);
else
Dfs(nn, node);
}
for (int i = 0; i < (int)V[node].size(); i++)
C[node].push_back(disc[V[node][i]]);
fin[node] = vr;
}
int Lca(int a, int b) {
if (dub[a] > dub[b]) swap(a, b);
for (int i = 0, raz = dub[b] - dub[a]; raz; raz /= 2, i++)
if (raz & 1) b = lca[b][i];
if (a == b) return a;
for (int i = LOG - 1; i >= 0; i--) {
if (lca[a][i] != lca[b][i]) {
a = lca[a][i];
b = lca[b][i];
}
}
return lca[a][0];
}
void Stavi(int node, int p[MAX], vector<int> &T) {
if (!p[node]) {
p[node] = 1;
T.push_back(node);
}
}
long long Rek(int node) {
dp[node][0] = dp[node][1] = 0;
for (int i = 0; i < (int)Vec[node].size(); i++) Rek(Vec[node][i]);
if (zgrada[node]) {
dp[node][0] = INF;
for (int i = 0; i < (int)Vec[node].size(); i++)
dp[node][1] += dp[Vec[node][i]][0];
} else {
long long maxraz = 0, sum1 = 0, sum0 = 0;
for (int i = 0; i < (int)Vec[node].size(); i++) {
int nn = Vec[node][i];
maxraz = max(maxraz, dp[nn][0] - dp[nn][1]);
sum1 += dp[nn][1];
sum0 += dp[nn][0];
}
dp[node][0] = min(sum0, sum1 + 1);
dp[node][1] = min(dp[node][0], sum0 - maxraz);
}
return dp[node][1];
}
long long Rijesi(const vector<int> &T) {
vector<int> Bitni;
vector<int> Lcaovi;
vector<pair<int, int> > Dtime;
vector<pair<int, int> > Dub;
for (int i = 0; i < (int)T.size(); i++) {
Dtime.push_back(pair<int, int>(disc[T[i]], T[i]));
Stavi(T[i], bitanlc, Lcaovi);
zgrada[T[i]] = 1;
}
sort(Dtime.begin(), Dtime.end());
for (int i = 0; i < (int)Dtime.size() - 1; i++)
Stavi(Lca(Dtime[i].second, Dtime[i + 1].second), bitanlc, Lcaovi);
for (int i = 0; i < (int)Lcaovi.size(); i++) Stavi(Lcaovi[i], bitan, Bitni);
for (int i = 0; i < (int)Lcaovi.size(); i++)
Dub.push_back(pair<int, int>(dub[Lcaovi[i]], Lcaovi[i]));
sort(Dub.begin(), Dub.end(), greater<pair<int, int> >());
set<int> S;
for (int i = 0; i < (int)Dub.size(); i++) {
int node = Dub[i].second;
for (set<int>::iterator it = S.lower_bound(disc[node]);
it != S.end() && *it < fin[node];) {
vector<int>::iterator itv =
lower_bound(C[node].begin(), C[node].end(), *it);
if (itv == C[node].end() || *itv > *it) itv--;
int nn = koji[*itv];
if (nn == koji[*it])
Vec[node].push_back(nn);
else {
Stavi(nn, bitan, Bitni);
Vec[node].push_back(nn);
Vec[nn].push_back(koji[*it]);
}
set<int>::iterator it2 = it++;
S.erase(it2);
}
S.insert(disc[node]);
}
int prvi = Bitni[0];
for (int i = 0; i < (int)Bitni.size(); i++)
if (dub[Bitni[i]] < dub[prvi]) prvi = Bitni[i];
long long ret = Rek(prvi);
for (int i = 0; i < (int)Bitni.size(); i++) {
int nn = Bitni[i];
Vec[nn].clear();
bitan[nn] = bitanlc[nn] = zgrada[nn] = 0;
}
return ret < MAX ? ret : -1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
V[a].push_back(b);
V[b].push_back(a);
}
Dfs(0, 0);
int brq;
scanf("%d", &brq);
for (; brq--;) {
int k;
scanf("%d", &k);
vector<int> T;
for (; k--;) {
int tmp;
scanf("%d", &tmp);
tmp--;
T.push_back(tmp);
}
printf("%lld\n", Rijesi(T));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
int m = n;
vector<int> yz;
for (int i = 2; i * i <= m; ++i) {
if (m % i == 0) {
int res = 1;
while (m % i == 0) {
m /= i;
res *= i;
}
yz.push_back(res);
}
}
if (m > 1) yz.push_back(m);
if (yz.size() <= 1) {
puts("NO");
} else {
puts("YES");
puts("2");
int b1 = yz[0];
int b2 = n / b1;
for (int a1 = 1;; ++a1) {
int a2 = n - 1 - a1 * b2;
if (a2 % b1 == 0) {
a2 /= b1;
printf("%d %d\n", a1, b1);
printf("%d %d\n", a2, b2);
break;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, dp[40][2];
long long solve(int i, bool c) {
bool s = n & (1LL << i);
bool x = m & (1LL << i);
if (c ^ s ^ x) return 0;
if (1LL << i > m) return 1;
if (dp[i][c] != -1) return dp[i][c];
return dp[i][c] = solve(i + 1, x ? c : 1) + solve(i + 1, x ? c : 0);
}
int main() {
cin >> n >> m;
memset(dp, -1, sizeof(dp));
cout << (solve(0, 0) - (n == m ? 2 : 0)) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y, i, j, k, p = 1, q = 1;
cin >> n >> x >> y;
long long int a[n + 1];
a[0] = 0;
for (i = 1; i <= n; i += 1) cin >> a[i];
for (i = 1; i <= n; i += 1) {
p = q = 1;
for (j = i - 1; j >= i - x && j > 0; j -= 1) {
if (a[j] <= a[i]) {
p = 0;
break;
}
}
for (k = i + 1; k <= i + y && k <= n; k += 1) {
if (a[k] <= a[i]) {
q = 0;
break;
}
}
if (p == 1 && q == 1) break;
}
cout << i << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int l, r;
int cnt[3];
};
int N, M;
string s;
int arr[200005];
set<int> st[3];
Node seg[1000000];
void pu(int idx) {
for (int k = 0; k < 3; k++) {
seg[idx].cnt[k] = seg[2 * idx].cnt[k] + seg[2 * idx + 1].cnt[k];
}
}
void build(int l, int r, int idx) {
seg[idx].l = l;
seg[idx].r = r;
if (l == r) {
seg[idx].cnt[arr[l]]++;
return;
}
int mid = (l + r) / 2;
build(l, mid, 2 * idx);
build(mid + 1, r, 2 * idx + 1);
pu(idx);
}
void upd(int p, int t, int v, int idx) {
if (seg[idx].l == seg[idx].r) {
seg[idx].cnt[t] += v;
return;
}
int mid = (seg[idx].l + seg[idx].r) / 2;
if (p <= mid) {
upd(p, t, v, 2 * idx);
} else {
upd(p, t, v, 2 * idx + 1);
}
pu(idx);
}
int query(int l, int r, int t, int idx) {
if (seg[idx].l == l && seg[idx].r == r) {
return seg[idx].cnt[t];
}
int mid = (seg[idx].l + seg[idx].r) / 2;
if (r <= mid) {
return query(l, r, t, 2 * idx);
} else if (l > mid) {
return query(l, r, t, 2 * idx + 1);
} else {
return query(l, mid, t, 2 * idx) + query(mid + 1, r, t, 2 * idx + 1);
}
}
int solve() {
int ret = N;
for (int k = 0; k < 3; k++) {
if (st[(k + 1) % 3].size() && st[(k + 2) % 3].empty()) {
ret -= query(1, N, k, 1);
} else {
int ll = st[(k + 1) % 3].size() ? (*st[(k + 1) % 3].begin()) : N + 2;
int lw = st[(k + 2) % 3].size() ? (*st[(k + 2) % 3].begin()) : N + 1;
if (ll < lw) {
ret -= query(ll, lw - 1, k, 1);
}
int rl = st[(k + 1) % 3].size() ? (*st[(k + 1) % 3].rbegin()) : -2;
int rw = st[(k + 2) % 3].size() ? (*st[(k + 2) % 3].rbegin()) : -1;
if (rl > rw) {
ret -= query(rw + 1, rl, k, 1);
}
}
}
return ret;
}
int typ(char c) {
if (c == 'R') {
return 0;
} else if (c == 'P') {
return 1;
} else {
return 2;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M >> s;
for (int i = 1; i <= N; i++) {
arr[i] = typ(s[i - 1]);
st[arr[i]].insert(i);
}
build(1, N, 1);
cout << solve() << "\n";
while (M--) {
int n;
char c;
cin >> n >> c;
upd(n, arr[n], -1, 1);
st[arr[n]].erase(n);
arr[n] = typ(c);
upd(n, arr[n], 1, 1);
st[arr[n]].insert(n);
cout << solve() << "\n";
}
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.