solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int a, ta;
cin >> a >> ta;
int b, tb;
cin >> b >> tb;
string time;
cin >> time;
int hours = (time[0] - '0') * 10;
hours += (time[1] - '0');
int minutes = (time[3] - '0') * 10 + (time[4] - '0');
int start = (hours - 5) * 60 + minutes;
int End = start + ta;
int before = (start / b) + 1;
int cnt = 0;
for (int i = 0; i < before; i++) {
int leave = i * b;
if (leave + tb > start) cnt++;
}
for (int i = start + 1; i < End; i++) {
if (i % b == 0 && i < 19 * 60) cnt++;
}
cout << cnt << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int sum = 0;
while (s) {
if (s >= n) {
s -= n;
sum++;
} else
n--;
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int K = 64, N = 3e5 + 7;
int a[N];
int sum[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
a[i] = __builtin_popcountll(x);
sum[i] = sum[i - 1] + a[i];
}
long long ans = 0;
int odd = 0, even = 1;
for (int i = 1; i <= n; i++) {
if (sum[i] % 2) {
ans += odd;
odd++;
} else {
ans += even;
even++;
}
int mx = 0, sm = 0;
for (int j = 0; j < K && j < i; j++) {
int cur = i - j;
mx = max(mx, a[cur]);
sm += a[cur];
if (sm % 2 == 0 && 2 * mx > sm) ans--;
}
}
cout << ans << endl;
}
| 2 |
#include <iostream>
#include <cstring>
#include <stdlib.h>
#include <vector>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <math.h>
#include <string>
using namespace std;
typedef long long ll;
ll func(ll b,ll n)
{
if(n<b) return n;
else{
return func(b, n/b)+n%b;
}
}
int main()
{
ll n,s;
cin >> n >> s;
if(n==s){
cout << n+1;
return 0;
}
for(ll i=2; i<=ll(sqrt(n)); i++){
if(func(i, n)==s){
cout << i;
return 0;
}
}
for(ll i=ll(sqrt(n)); i>=1; i--){//上位桁について
ll b=(n-s)/i+1;
if(b<2) break;
if(func(b,n)==s){
cout << b;
return 0;
}
}
cout << -1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> p1, pair<int, int> p2) {
return (p1.first < p2.first) ||
(p1.first == p2.first && p1.second > p2.second);
}
int main() {
bool b[200000];
int t[200000];
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> t[i];
b[i] = true;
}
int answer = 1;
for (int i = 2; i <= n; ++i) {
if (t[i] == 0) {
++answer;
continue;
}
if (b[t[i]])
b[t[i]] = false;
else
++answer;
}
cout << answer;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int p, y;
cin >> p >> y;
int len = min(p, (int)sqrt(y + 1));
while (1) {
int i;
for (i = 2; i <= len; ++i) {
if (y % i == 0) break;
}
if (i > len) {
y > p ? cout << y : cout << -1;
return 0;
}
y--;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
_out << _p.first << ' ' << _p.second;
return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
_in >> _p.first >> _p.second;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
if (_v.empty()) {
return _out;
}
_out << _v.front();
for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) {
_in >> _i;
}
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
const string FILENAME = "input";
const int MAXN = 200228;
const int M = 1000000007;
const long long base = 1000000000000000000LL;
struct fenwick {
vector<long long> f;
int nn;
void init(int n) {
f.resize(n, 0);
nn = n;
}
void inc(int i, long long val) {
for (int j = i; j < nn; j = (j | (j + 1))) {
f[j] += val;
}
}
long long getsum(int l) {
if (l < 0) {
return 0;
}
long long t = 0;
for (int j = l; j >= 0; j = (j & (j + 1)) - 1) {
t += f[j];
}
return t;
}
long long get(int l, int r) { return getsum(r) - getsum(l - 1); }
};
struct fenwick1 {
vector<long long> f;
int nn;
void init(int n) {
f.resize(n, 0);
nn = n;
}
void inc(int i, long long val) {
for (int j = i; j < nn; j = (j | (j + 1))) {
f[j] += val;
f[j] %= M;
}
}
long long getsum(int l) {
if (l < 0) {
return 0;
}
long long t = 0;
for (int j = l; j >= 0; j = (j & (j + 1)) - 1) {
t += f[j];
t %= M;
}
return t;
}
long long get(int l, int r) { return (getsum(r) - getsum(l - 1)) % M; }
};
int n, q;
int a[MAXN];
int w[MAXN];
fenwick wss;
fenwick1 wss1;
fenwick1 pref;
fenwick1 suff;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
wss.init(n);
wss1.init(n);
pref.init(n);
suff.init(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> w[i];
wss.inc(i, w[i]);
wss1.inc(i, 1LL * w[i] * a[i] % M);
}
for (int i = 0; i < n; i++) {
pref.inc(i, 1LL * w[i] * (i + 1) % M);
}
for (int i = 0; i < n; i++) {
suff.inc(i, 1LL * w[i] * (n - i) % M);
}
for (int it = 0; it < q; it++) {
int first;
cin >> first;
if (first < 0) {
int second;
cin >> second;
first *= -1;
first--;
wss.inc(first, second - w[first]);
wss1.inc(first,
(1LL * second * a[first]) % M - (1LL * w[first] * a[first]) % M);
pref.inc(first, (1LL * second * (first + 1)) % M -
1LL * w[first] * (first + 1) % M);
suff.inc(first, (1LL * second * (n - first)) % M -
1LL * w[first] * (n - first) % M);
w[first] = second;
} else {
int second;
cin >> second;
first--, second--;
int l = first;
int r = second;
long long f = wss.get(first, second);
while (l != r) {
int mid = (l + r) >> 1;
long long k = wss.get(first, mid);
if (k >= f - k) {
r = mid;
} else {
l = mid + 1;
}
}
long long ans = 0;
if (first < l) {
long long t = wss1.get(first, l - 1);
long long f = 1LL * a[l] * (wss.get(first, l - 1) % M) % M;
f -= suff.get(first, l - 1);
f += (wss.get(first, l - 1) * (n - l)) % M;
f -= t;
f %= M;
if (f < 0) {
f += M;
}
ans += f;
ans %= M;
}
if (l + 1 <= second) {
long long t = wss1.get(l + 1, second);
long long f = 1LL * a[l] * (wss.get(l + 1, second) % M) % M;
f += pref.get(l + 1, second);
f -= (wss.get(l + 1, second) * (l + 1)) % M;
t -= f;
t %= M;
if (t < 0) {
t += M;
}
ans += t;
ans %= M;
}
cout << ans << '\n';
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, s, i, a[200010], sum = 0, j;
cin >> n >> s;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (a[n / 2] == s)
cout << 0 << endl;
else if (a[n / 2] > s) {
sum += a[n / 2] - s;
j = n / 2;
j--;
for (j = j; j >= 0; j--) {
if (a[j] > s)
sum += a[j] - s;
else
break;
}
cout << sum << endl;
} else if (a[n / 2] < s) {
sum += s - a[n / 2];
j = n / 2;
j++;
for (j = j; j < n; j++) {
if (a[j] < s)
sum += s - a[j];
else
break;
}
cout << sum << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
string x;
cin >> x;
string y = x;
for (long long int i = k; i < n; i++) y[i] = y[i - k];
if (y < x) {
long long int j = k - 1;
while (y[j] == '9') {
y[j] = '0';
j--;
}
y[j] += 1;
for (long long int i = k; i < n; i++) y[i] = y[i - k];
}
cout << n << endl;
cout << y << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
int p[n];
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
int temp = p[i];
int cnt = 1;
while (temp != i + 1) {
temp = p[temp - 1];
cnt++;
}
cout << cnt << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int max(int a, int b) {
if (a > b) {
return a;
}
return b;
}
int min(int a, int b) {
if (a < b) {
return a;
}
return b;
}
int zt(int a, int b) { return max(a, b) - min(a, b); }
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int ceil(int a, int b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
int lcm(int a, int b) {
int c = gcd(a, b);
a /= c;
return a * b;
}
int nCr(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
int nHr(int a, int b) { return nCr(a + b - 1, b); }
int fact(int a) {
int i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
int pow(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
long long llmax(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long llmin(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long llzt(long long a, long long b) { return llmax(a, b) - llmin(a, b); }
long long llround(long long a, long long b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
long long llceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
long long llgcd(long long a, long long b) {
long long c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long lllcm(long long a, long long b) {
long long c = llgcd(a, b);
a /= c;
return a * b;
}
long long llnCr(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
long long llnHr(long long a, long long b) { return llnCr(a + b - 1, b); }
long long llfact(long long a) {
long long i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
long long llpow(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
double dbmax(double a, double b) {
if (a > b) {
return a;
}
return b;
}
double dbmin(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double dbzt(double a, double b) { return dbmax(a, b) - dbmin(a, b); }
int sortfncsj(const void *a, const void *b) {
if (*(int *)a > *(int *)b) {
return 1;
}
if (*(int *)a == *(int *)b) {
return 0;
}
return -1;
}
int sortfnckj(const void *a, const void *b) {
if (*(int *)a < *(int *)b) {
return 1;
}
if (*(int *)a == *(int *)b) {
return 0;
}
return -1;
}
int llsortfncsj(const void *a, const void *b) {
if (*(long long *)a > *(long long *)b) {
return 1;
}
if (*(long long *)a == *(long long *)b) {
return 0;
}
return -1;
}
int llsortfnckj(const void *a, const void *b) {
if (*(long long *)a < *(long long *)b) {
return 1;
}
if (*(long long *)a == *(long long *)b) {
return 0;
}
return -1;
}
int dbsortfncsj(const void *a, const void *b) {
if (*(double *)a > *(double *)b) {
return 1;
}
if (*(double *)a == *(double *)b) {
return 0;
}
return -1;
}
int dbsortfnckj(const void *a, const void *b) {
if (*(double *)a < *(double *)b) {
return 1;
}
if (*(double *)a == *(double *)b) {
return 0;
}
return -1;
}
int strsortfncsj(const void *a, const void *b) {
return strcmp((char *)a, (char *)b);
}
int strsortfnckj(const void *a, const void *b) {
return strcmp((char *)b, (char *)a);
}
int main(void) {
int i, j, n, m, k, a[262144], b, c, w, r = 0, l, t;
double d;
char s[4][128];
scanf("%d%d", &n, &k);
if (n == 3 && k > 2) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (i = 0; i < 4; i++) {
for (j = 0; j < n; j++) {
s[i][j] = '.';
}
s[i][n] = 0;
}
if (k % 2 == 1 && !(k > (n - 2))) {
w = (n - k) / 2;
for (j = w; j < n - w; j++) {
s[1][j] = '#';
}
} else if (k % 2 == 0) {
for (j = 1; j <= (k / 2); j++) {
s[1][j] = '#';
s[2][j] = '#';
}
} else {
w = n - 2;
w = k - w;
w--;
s[1][n - 2] = '#';
s[2][n - 2] = '#';
for (j = 1; j < 1 + w; j++) {
s[1][j] = '#';
s[2][j] = '#';
}
for (j = 1 + w; j < n - 2; j++) {
if (j % 2) {
s[1][j] = '#';
} else {
s[2][j] = '#';
}
}
}
for (i = 0; i < 4; i++) {
printf("%s\n", s[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e7;
const long long N = 5e5 + 1;
const long long mod = 1e9 + 7;
const long double eps = 1E-7;
long long n, m, cnt, x, y, a[N];
string s;
int main() {
cin >> n >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'n') x++;
if (s[i] == 'z') y++;
}
for (int i = 0; i < x; i++) cout << 1 << ' ';
for (int i = 0; i < y; i++) cout << 0 << ' ';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
char mas[2][2], mas1[2][2], Prob[2][2];
cin >> s;
mas[0][0] = s[0];
mas[0][1] = s[1];
cin >> s;
mas[1][0] = s[0];
mas[1][1] = s[1];
cin >> s;
mas1[0][0] = s[0];
mas1[0][1] = s[1];
cin >> s;
mas1[1][0] = s[0];
mas1[1][1] = s[1];
Prob[0][0] = mas[0][0];
Prob[0][1] = mas[0][1];
Prob[1][0] = mas[1][0];
Prob[1][1] = mas[1][1];
for (int i = 0; i < 100; i++) {
if (Prob[0][0] == 'X') {
swap(Prob[0][0], Prob[0][1]);
} else if (Prob[0][1] == 'X') {
swap(Prob[0][1], Prob[1][1]);
} else if (Prob[1][0] == 'X') {
swap(Prob[1][0], Prob[0][0]);
} else if (Prob[1][1] == 'X') {
swap(Prob[1][0], Prob[1][1]);
}
if (Prob[0][0] == mas1[0][0] && Prob[0][1] == mas1[0][1] &&
Prob[1][1] == mas1[1][1] && Prob[1][0] == mas1[1][0]) {
cout << "YES";
return 0;
}
}
Prob[0][0] = mas[0][0];
Prob[0][1] = mas[0][1];
Prob[1][0] = mas[1][0];
Prob[1][1] = mas[1][1];
for (int i = 0; i < 100; i++) {
if (Prob[0][0] == 'X') {
swap(Prob[0][0], Prob[1][0]);
} else if (Prob[0][1] == 'X') {
swap(Prob[0][1], Prob[0][0]);
} else if (Prob[1][0] == 'X') {
swap(Prob[1][0], Prob[1][1]);
} else if (Prob[1][1] == 'X') {
swap(Prob[0][1], Prob[1][1]);
}
if (Prob[0][0] == mas1[0][0] && Prob[0][1] == mas1[0][1] &&
Prob[1][1] == mas1[1][1] && Prob[1][0] == mas1[1][0]) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
clock_t t_;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main(int argc, const char* argv[]) {
t_ = clock();
string s;
cin >> s;
string ret = "";
ret += s[0];
int j = 1;
int n = s.length();
vector<int> ans(n);
ans[0] = 0;
vector<int> ind;
int rev = 0;
while (j < n) {
if (s[j] <= ret[0]) {
ans[j - 1] ^= 1;
ans[j] = 1;
ret = s[j] + ret;
} else {
ans[j] = 0;
ret += s[j];
}
j++;
}
for (int i = int(0); i < int(n); i++) cout << ans[i] << " ";
cout << "\n";
t_ = clock() - t_;
cerr << setprecision(9) << fixed << ((float)t_ / CLOCKS_PER_SEC) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a[210000], w[210000];
long long W[210000], AW[210000];
void modify(long long *b, int x, long long y) {
for (; x <= n; x += x & -x) b[x] += y;
}
long long query(long long *b, int x) {
long long ans = 0;
for (; x; x -= x & -x) ans += b[x];
return ans;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
}
for (int i = 1; i <= n; i++) {
modify(W, i, w[i]);
modify(AW, i, 1LL * a[i] * w[i] % 1000000007);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
modify(W, x, -w[x]);
modify(AW, x, -(1LL * a[x] * w[x] % 1000000007));
w[x] = y;
modify(W, x, w[x]);
modify(AW, x, (1LL * a[x] * w[x] % 1000000007));
} else {
long long base = query(W, x - 1);
long long SW = query(W, y) - base;
int l = x - 1, r = y, mid;
while (l < r - 1) {
mid = (l + r) / 2;
if (query(W, mid) - base >= (SW + 1) / 2)
r = mid;
else
l = mid;
}
long long ans = 0;
if (x < r) {
ans += 1LL * a[r] * ((query(W, r - 1) - query(W, x - 1)) % 1000000007) %
1000000007;
ans -= (query(AW, r - 1) - query(AW, x - 1)) % 1000000007;
}
if (r < y) {
ans -= 1LL * a[r] * ((query(W, y) - query(W, r)) % 1000000007) %
1000000007;
ans += (query(AW, y) - query(AW, r)) % 1000000007;
}
ans = ((ans % 1000000007) + 1000000007) % 1000000007;
printf("%I64d\n", ans);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007, MAX = 100005, INF = 1 << 30;
struct point {
int p;
int x;
int y;
};
bool compare(point a, point b) {
if (a.p == b.p) return a.x < b.x;
return a.p > b.p;
}
int main() {
int T;
cin >> T;
for (int k = 0; k < T; k++) {
int N, M;
cin >> N >> M;
if (N <= 3) {
vector<int> A(N * M);
for (int i = 0; i < N * M; i++) {
cin >> A[i];
}
sort((A).begin(), (A).end());
reverse((A).begin(), (A).end());
int ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i];
}
cout << ans << endl;
} else {
vector<point> A(N * M), B(N * M);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
int x;
cin >> x;
A[i * M + j] = {x, i, j};
B[i * M + j] = A[i * M + j];
}
}
sort((A).begin(), (A).end(), compare);
set<int> a;
for (int i = 0; i < 4; i++) {
a.insert(A[i].y);
}
if (a.size() != 2) {
int ans = 0;
for (int i = 0; i < N; i++) {
ans += A[i].p;
}
cout << ans << endl;
} else {
int s, t, u = -1;
auto it = a.begin();
s = (*it);
it++;
t = (*it);
for (int i = 4; i < N * M; i++) {
if (A[i].y != s && A[i].y != t) {
u = A[i].p;
break;
}
}
int ans = 0;
if (u == -1) {
for (int bit = 0; bit < (1 << 8); bit++) {
vector<int> on;
int sum = 0;
for (int i = 0; i < 8; i++) {
if (bit & (1 << i)) on.push_back(i);
}
if (on.size() != 4) continue;
if (on[1] <= 3 && on[2] >= 4) {
if ((on[1] - on[0] == 2 && on[3] - on[2] != 2) ||
(on[1] - on[0] != 2 && on[3] - on[2] == 2))
continue;
for (int j = 0; j < 4; j++) {
if (on[j] <= 3) {
sum += B[on[j] * M + s].p;
} else {
sum += B[(on[j] - 4) * M + t].p;
}
}
ans = max(ans, sum);
} else {
for (int j = 0; j < 4; j++) {
if (on[j] <= 3) {
sum += B[on[j] * M + s].p;
} else {
sum += B[(on[j] - 4) * M + t].p;
}
}
ans = max(ans, sum);
}
}
} else {
for (int bit = 0; bit < (1 << 8); bit++) {
vector<int> on;
int sum = 0;
for (int i = 0; i < 8; i++) {
if (bit & (1 << i)) on.push_back(i);
}
if (on.size() == 4) {
if (on[1] <= 3 && on[2] >= 4) {
if ((on[1] - on[0] == 2 && on[3] - on[2] != 2) ||
(on[1] - on[0] != 2 && on[3] - on[2] == 2))
continue;
for (int j = 0; j < 4; j++) {
if (on[j] <= 3) {
sum += B[on[j] * M + s].p;
} else {
sum += B[(on[j] - 4) * M + t].p;
}
}
ans = max(ans, sum);
} else {
for (int j = 0; j < 4; j++) {
if (on[j] <= 3) {
sum += B[on[j] * M + s].p;
} else {
sum += B[(on[j] - 4) * M + t].p;
}
}
ans = max(ans, sum);
}
} else if (on.size() == 3) {
for (int j = 0; j < 3; j++) {
if (on[j] <= 3) {
sum += B[on[j] * M + s].p;
} else {
sum += B[(on[j] - 4) * M + t].p;
}
}
sum += u;
ans = max(ans, sum);
}
}
}
cout << ans << endl;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100100];
int b[100100];
int c[100100];
int n;
int k;
long long tt() {
int k1 = k;
for (int i = 1; i <= n; i++) c[i] = 0;
for (int i = 0; i < k; i++) c[a[i]] += 1;
while (k1 <= n / 2) {
c[a[k1]]++;
if (2 * c[a[k1]] > b[a[k1]]) break;
k1++;
}
if (n % 2 == 1 && k1 == n / 2 && b[a[k1]] % 2 == 1) k1++;
if (k1 > n / 2 || (n % 2 == 0 && k1 >= n / 2)) {
while (a[k1] == a[n - k1 - 1]) k1++;
}
long long t = (k1 + 1);
t *= k + 1;
return t;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
b[a[i]]++;
}
bool t = false;
for (int i = 1; i <= n; i++)
if (b[i] % 2) {
if (t) {
cout << 0;
return 0;
}
t = true;
}
k = 0;
long long res = 0;
while (k <= n / 2 && a[k] == a[n - k - 1]) k++;
if (k > n / 2) {
res = n;
res *= n + 1;
res /= 2;
cout << res;
return 0;
}
res = tt();
reverse(a, a + n);
res += tt();
long long r = k + 1;
r *= r;
cout << res - r;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod1 = 19260817;
const long long mod2 = 19660813;
char s[200005];
int s1[200005];
int s2[200005];
int n;
long long inv[200005];
long long invf[200005];
long long fac[200005];
long long C(int n, int m) {
if (n < 0 || m < 0 || m > n) return 0;
if (m == 0 || m == n) return 1;
return fac[n] * invf[n - m] % 1000000007 * invf[m] % 1000000007;
}
void init() {
inv[1] = inv[0] = 1LL;
for (long long i = 2; i < 200005; ++i)
inv[i] = (1000000007 - 1000000007 / i) * inv[1000000007 % i] % 1000000007;
invf[0] = 1LL;
for (long long i = 1; i < 200005; ++i)
invf[i] = invf[i - 1] * inv[i] % 1000000007;
fac[0] = 1LL;
for (long long i = 1; i < 200005; ++i) fac[i] = fac[i - 1] * i % 1000000007;
}
int main() {
init();
scanf("%s", s + 1);
n = (int)strlen(s + 1);
for (int i = 1; i <= n; ++i) s1[i] = s1[i - 1] + (s[i] == '(');
for (int i = n; i >= 1; --i) s2[i] = s2[i + 1] + (s[i] == ')');
long long ans = 0;
for (int i = 1; i <= n; ++i) {
if (s[i] == ')') continue;
int S1 = s1[i];
int S2 = s2[i];
ans = (ans + C(S1 + S2, S1) - C(S1 + S2 - 1, S1 - 1)) % 1000000007;
ans = (ans + 1000000007) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const uint32_t MAX_N = 1.01e5;
const uint32_t BUCKET_SIZE = 185;
const uint32_t MAX_BUCK = MAX_N / BUCKET_SIZE;
inline int64_t ceil_r(int64_t n, int64_t d) {
if (d < 0) {
n *= -1;
d *= -1;
}
if (n < 0) {
return n / d;
} else {
return (n + d - 1) / d;
}
}
struct Line {
int64_t a, b;
Line(int64_t a = 0, int64_t b = 0) : a(a), b(b) {}
int64_t operator()(int64_t x) const { return a * x + b; }
static int64_t intersect_x(const Line &l1, const Line &l2) {
int64_t num = l1.b - l2.b;
int64_t denum = l2.a - l1.a;
return ceil_r(num, denum);
}
};
uint32_t priceCnt[MAX_N + BUCKET_SIZE];
struct Bucket {
uint32_t start, len;
uint32_t size;
std::vector<std::pair<Line, int64_t>> lines;
Bucket() : start(0), len(BUCKET_SIZE), size(0) {}
void recalc() {
std::vector<Line> tempLines(len);
size = 0;
for (uint32_t i = 0; i < len; i++) {
int64_t j = start + len - i - 1;
size += priceCnt[j];
tempLines[j - start] = Line(j, size * j);
}
lines.clear();
for (uint32_t i = 0; i < tempLines.size(); i++) {
while (!lines.empty()) {
int64_t x = Line::intersect_x(lines.back().first, tempLines[i]);
if (x <= lines.back().second) {
lines.pop_back();
} else {
break;
}
}
int64_t startX = 0;
if (!lines.empty()) {
startX = Line::intersect_x(lines.back().first, tempLines[i]);
}
if (startX < 2 * MAX_N) {
lines.push_back({tempLines[i], startX});
}
}
}
std::pair<int64_t, int64_t> best_val(int64_t x) {
uint32_t l = 0;
uint32_t h = lines.size();
while (h - l > 1) {
uint32_t m = (h + l) / 2;
if (lines[m].second <= x) {
l = m;
} else {
h = m;
}
}
return {lines[l].first(x), lines[l].first.a};
}
};
Bucket buckets[MAX_BUCK];
struct Person {
uint32_t a, b;
uint32_t bucket() const { return a / BUCKET_SIZE; }
friend bool operator<(const Person &a, const Person &b) { return a.b < b.b; }
};
std::vector<Person> people;
int64_t adPrice;
uint32_t maxBanner;
void input() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
uint32_t peopleCnt;
std::cin >> peopleCnt >> adPrice;
people.resize(peopleCnt);
maxBanner = 0;
for (Person &i : people) {
std::cin >> i.a >> i.b;
maxBanner = std::max(maxBanner, i.b);
}
std::sort(people.begin(), people.end());
}
void init_buckets() {
for (uint32_t i = 0; i < MAX_BUCK; i++) {
buckets[i].start = i * BUCKET_SIZE;
buckets[i].recalc();
}
}
std::pair<int64_t, int64_t> calc() {
std::pair<int64_t, int64_t> ans = {0, 0};
uint32_t curCnt = 0;
for (uint32_t i = MAX_BUCK - 1; i < MAX_BUCK; i--) {
auto curAns = buckets[i].best_val(curCnt);
ans = std::max(ans, curAns);
curCnt += buckets[i].size;
}
return ans;
}
int main() {
input();
init_buckets();
uint32_t peopleI = 0;
int64_t curPeople = people.size();
for (uint32_t i = 0; i <= 1 + maxBanner; i++) {
while ((peopleI < people.size()) && (people[peopleI].b < i)) {
uint32_t a = people[peopleI].a;
priceCnt[a]++;
buckets[a / BUCKET_SIZE].recalc();
peopleI++;
curPeople--;
}
int64_t adRevenue = curPeople * i * adPrice;
auto ans = calc();
std::cout << ans.first + adRevenue << " " << ans.second << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
int arr[N], grr[100006] = {0}, fre[100005] = {0}, x, ma = 0, ans = 0;
for (int i = 0; i < N; i++) {
bool ok = false;
cin >> x;
grr[fre[x]]--;
fre[x]++;
grr[fre[x]]++;
ma = max(ma, fre[x]);
if (grr[1] == i + 1)
ok = true;
else if (grr[i + 1] == 1)
ok = true;
else if (grr[ma - 1] * (ma - 1) == i + 1 - ma && grr[ma] == 1)
ok = true;
else if (grr[1] == 1 && grr[ma] * (ma) == i)
ok = true;
if (ok) ans = i + 1;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int val[100009];
int n;
int ar[100009];
void upd(int idx, int v) {
while (idx <= n) {
ar[idx] += v;
idx += (idx & (-idx));
}
}
int quer(int idx) {
int r = 0;
while (idx) {
r += ar[idx];
idx -= (idx & (-idx));
}
return r;
}
struct node {
int ind, mn;
node(int a, int b) {
ind = a;
mn = b;
}
node() {}
} tree[4 * 100009];
node mergenode(node a, node b) {
if (a.mn < b.mn)
return a;
else if (a.mn > b.mn)
return b;
else if (a.ind < b.ind)
return a;
else
return b;
}
void build(int ind, int st, int ed) {
if (st == ed) {
tree[ind] = node(st, val[st]);
} else {
build(2 * ind, st, (st + ed) / 2);
build(2 * ind + 1, (st + ed) / 2 + 1, ed);
tree[ind] = mergenode(tree[2 * ind], tree[2 * ind + 1]);
}
}
void update(int ind, int st, int ed, int i) {
if (i < st || i > ed) {
return;
} else if (st == ed) {
tree[ind] = node(st, 10000000);
return;
}
update(2 * ind, st, (st + ed) / 2, i);
update(2 * ind + 1, (st + ed) / 2 + 1, ed, i);
tree[ind] = mergenode(tree[2 * ind], tree[2 * ind + 1]);
}
node query(int ind, int st, int ed, int i, int j) {
if (st > j || ed < i) {
return node(st, 100000000);
} else if (st >= i && ed <= j) {
return tree[ind];
} else
return mergenode(query(2 * ind, st, (st + ed) / 2, i, j),
query(2 * ind + 1, (st + ed) / 2 + 1, ed, i, j));
}
int main() {
int i, j;
long long int tot = 0ll;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &val[i]);
upd(i, 1);
}
build(1, 1, n);
int lst = 1;
node nw1, nw2;
for (i = 0; i < n; i++) {
nw1 = query(1, 1, n, lst, n);
nw2 = query(1, 1, n, 1, lst);
if (nw1.mn <= nw2.mn) {
tot += (quer(nw1.ind) - quer(lst - 1));
update(1, 1, n, nw1.ind);
upd(nw1.ind, -1);
lst = nw1.ind;
} else {
tot += (quer(n) - quer(lst - 1) + quer(nw2.ind));
update(1, 1, n, nw2.ind);
upd(nw2.ind, -1);
lst = nw2.ind;
}
}
printf("%lld\n", tot);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
for (int x1 = -a + 1; x1 <= a; x1++) {
for (int x2 = -b + 1; x2 <= b; x2++) {
if (!x1 or !x2 or x1 == x2) continue;
int y1 = sqrt(a * a - x1 * x1);
int y2 = sqrt(b * b - x2 * x2);
if (y1 * y1 + x1 * x1 != a * a or y2 * y2 + x2 * x2 != b * b) continue;
if (y1 == y2) continue;
int vt = x1 * x2 + y1 * y2;
if (vt != 0) continue;
int d = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
if (d != a * a + b * b) continue;
cout << "YES" << endl;
cout << "0 0" << endl;
cout << x1 << " " << y1 << endl;
cout << x2 << " " << y2 << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
struct node {
int u, v, l, r;
bool operator<(const node& C) const { return l > C.l; }
};
struct data {
int nt, to, r;
} a[N * 10];
int head[N][2], L[N][2], cnt = 0;
priority_queue<node> q;
void add(int x, int y, int r, int opt) {
a[++cnt].to = y, a[cnt].r = r;
a[cnt].nt = head[x][opt], head[x][opt] = cnt;
}
void insert(int u, int v, int l, int r) { q.push((node){u, v, l, r}); }
void go(int u, int l, int r, int opt) {
L[u][opt] = max(L[u][opt], r);
for (int i = head[u][opt]; i; i = a[i].nt) {
insert(u, a[i].to, l, a[i].r);
}
head[u][opt] = 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n == 1) {
return printf("0\n"), 0;
}
for (int i = 1; i <= m; ++i) {
int u, v, l, r;
scanf("%d%d%d%d", &u, &v, &l, &r);
r--;
int pos = r - l;
insert(u, v, l, r - (pos & 1));
insert(v, u, l, r - (pos & 1));
insert(u, v, l + 1, r - (!(pos & 1)));
insert(v, u, l + 1, r - (!(pos & 1)));
}
memset(L, 255, sizeof(L));
L[1][0] = 0;
while (!q.empty()) {
node h = q.top();
q.pop();
if (h.l > h.r) {
continue;
}
int opt = h.l & 1;
if (L[h.u][opt] >= h.l) {
if (h.v == n) {
printf("%d\n", h.l + 1);
return 0;
}
go(h.v, h.l + 1, h.r + 1, opt ^ 1);
} else {
add(h.u, h.v, h.r, opt);
}
}
puts("-1");
return 0;
}
| 6 |
/**
* author: qodjf
* created: 01.28.2021 22:35:02
*/
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifndef ONLINE_JUDGE
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define dbg(...) 42
#endif
template <class T>
inline bool chmax(T &a, T b) {
return a < b && (a = b, true);
}
template <class T>
inline bool chmin(T &a, T b) {
return a > b && (a = b, true);
}
#define mst(x, a) memset(x, a, sizeof(x))
#define all(a) begin(a), end(a)
#define rep(i, begin, end) \
for (__typeof(end) i = (begin) - ((begin) > (end)); \
i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
using ll = long long;
using P = pair<int, int>;
using T = tuple<int, int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr ll LLINF = 0x3f3f3f3f3f3f3f3f;
constexpr ll MOD = 1e9 + 7;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
inline ll square(ll a) { return a * a; }
inline ll dis(P &a, P &b) {
return square(a.first - b.first) + square(a.second - b.second);
}
int n;
vector<P> points;
vector<bool> used;
void solve() {
cin >> n;
points.resize(n);
used = vector<bool>(n, false);
rep(i, 0, n) { cin >> points[i].first >> points[i].second; }
vector<int> ans;
int choosed = 0;
rep(i, 0, n) {
used[choosed] = true;
ans.push_back(choosed + 1);
ll maxDis = 0, next = -1;
rep(j, 0, n) {
if (!used[j]) {
if (chmax(maxDis, dis(points[choosed], points[j]))) {
next = j;
}
}
}
choosed = next;
}
rep(i, 0, n) {
cout << ans[i] << ' ';
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string second;
cin >> second;
for (size_t i = 1; i < second.size() - 1; i++) {
if (second[i - 1] != second[i + 1] && second[i] != second[i - 1] &&
second[i] != second[i + 1] && second[i] != '.' &&
second[i - 1] != '.' && second[i + 1] != '.') {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
int n, m;
struct node {
char c;
int id;
} d[MAX];
char s[MAX];
int vis[MAX];
stack<node> q;
int main() {
int i, j, k, t;
while (~scanf("%s", s)) {
while (!q.empty()) q.pop();
n = strlen(s);
int ans = 0;
for (i = 0; i < n; i++) {
d[i].c = s[i];
d[i].id = i;
}
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
node now;
now.c = s[i];
now.id = i;
if (s[i] == '(' || s[i] == '[')
q.push(now);
else if (q.empty())
continue;
else if (s[i] == ']' && q.top().c == '[') {
vis[i] = 1;
vis[q.top().id] = 1;
q.pop();
} else if (s[i] == ')' && q.top().c == '(') {
vis[i] = 1;
vis[q.top().id] = 1;
q.pop();
} else {
while (!q.empty()) q.pop();
}
}
int num = 0;
int r;
int len = 0;
int cont = 0;
for (i = 0; i < n; i++) {
if (vis[i]) {
if (s[i] == '[') num++;
cont++;
} else
cont = num = 0;
if (num >= ans) {
ans = num;
r = i;
len = cont;
}
}
printf("%d\n", ans);
if (!ans) continue;
for (i = r - len + 1; i <= r; i++) printf("%c", s[i]);
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Fenwik {
int n;
vector<int> bit;
int max_value;
void unite(int n_, int max_value_) {
n = n_;
max_value = max_value_;
bit.assign(n + 1, 0);
}
int get(int L, int R) { return get(R) - get(L); }
int get(int pos) {
int ans = 0;
for (; pos > 0; pos -= pos & -pos) {
ans += bit[pos];
}
return ans;
}
void add(int pos, int delta) {
int val = get(pos, pos + 1);
delta = min(delta, max_value - val);
for (pos++; pos <= n; pos += pos & -pos) {
bit[pos] += delta;
}
}
};
int n, k, a, b, q;
Fenwik bit_a, bit_b;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> k >> a >> b >> q;
bit_a.unite(n, a);
bit_b.unite(n, b);
while (q--) {
int type;
cin >> type;
if (type == 1) {
int pos, delta;
cin >> pos >> delta;
pos--;
bit_a.add(pos, delta);
bit_b.add(pos, delta);
} else {
int pos;
cin >> pos;
pos--;
int ans = 0;
ans += bit_b.get(0, pos);
ans += bit_a.get(pos + k, n);
cout << ans << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<int, int>;
using vi = vector<int>;
constexpr int N = 5010, INF = 1000000010;
int n, c[N], d[N], s[N];
int b, dp[N][2][N];
vi g[N];
void dfs(int u) {
s[u] = 1;
for (int i = 0; i <= n; ++i) dp[u][0][i] = dp[u][1][i] = INF;
dp[u][0][0] = 0;
dp[u][0][1] = c[u];
dp[u][1][1] = c[u] - d[u];
for (int v : g[u]) {
dfs(v);
for (int i = s[u]; i >= 0; --i)
for (int j = 1; j <= s[v]; ++j) {
dp[u][0][i + j] = min(dp[u][0][i + j], dp[u][0][i] + dp[v][0][j]);
dp[u][1][i + j] =
min(dp[u][1][i + j], dp[u][1][i] + min(dp[v][0][j], dp[v][1][j]));
}
s[u] += s[v];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
cin >> n >> b;
for (int i = 0; i < n; ++i) {
cin >> c[i] >> d[i];
if (i) {
int u;
cin >> u;
--u;
g[u].push_back(i);
}
}
dfs(0);
for (int ans = n; ans >= 0; --ans)
if (min(dp[0][0][ans], dp[0][1][ans]) <= b) return cout << ans, 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 2e5 + 10;
int T, n, a[maxn], ans[maxn];
vector<int> v1[maxn], v2[maxn];
queue<int> q;
inline void work() {
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0, len = v2[u].size(); i < len; ++i) {
int v = v2[u][i];
if (!ans[v] && !((a[v] ^ a[u]) % 2)) ans[v] = ans[u] + 1, q.push(v);
}
}
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read(), ans[i] = 0;
for (int i = 1; i <= n; ++i) {
if (i + a[i] <= n) {
v1[i].push_back(i + a[i]);
v2[i + a[i]].push_back(i);
if ((a[i + a[i]] ^ a[i]) & 1) ans[i] = 1, q.push(i);
}
}
for (int i = 1; i <= n; ++i) {
if (i - a[i] >= 1) {
v1[i].push_back(i - a[i]);
v2[i - a[i]].push_back(i);
if ((a[i - a[i]] ^ a[i]) & 1) ans[i] = 1, q.push(i);
}
}
work();
for (int i = 1; i <= n; i++) {
if (!ans[i])
printf("%d ", -1);
else
printf("%d ", ans[i]);
}
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long l, r;
cin >> l >> r;
if (l * 2 > r)
cout << -1 << " " << -1 << '\n';
else {
cout << l << " " << l * 2 << '\n';
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n, c;
long long int arr[100005];
int main() {
int i, j;
scanf("%lld", &n);
scanf("%lld", &c);
for (i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
}
long long int k = 1;
for (i = 1; i < n; i++) {
if (arr[i] - arr[i - 1] > c)
k = 1;
else
k++;
}
cout << k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int T, H = 0, i;
int main() {
cin >> T;
int A[T];
for (i = 0; i < T; i++) {
cin >> A[i];
}
sort(A, A + T);
for (i = 1; i < T; i++) {
while (A[i] <= A[i - 1]) {
A[i]++;
H++;
}
}
cout << H << endl;
}
| 2 |
#include<bits/stdc++.h>
#define inf (ll)1e9
#define inff 0x3f3f3f3f
#define mem(x) memset(x,0,sizeof x)
#define ll long long
using namespace std;
int num=-1,n,m,s,t,cur[3010],head[3010],deep[3010];
int val[3010],a[3010];
ll ans;
bool mapp[110];
struct Edge{
int to,dis,next;
}edge[400010];
void add(int f,int t,int dis){
//cout<<"#"<<f<<" "<<t<<" "<<dis<<endl;
edge[++num]={t,dis,head[f]};head[f]=num;
edge[++num]={f,0,head[t]};head[t]=num;
}
queue<int>q;
bool bfs(int s,int t){
for(int i=s;i<=t;i++) cur[i]=head[i];
memset(deep,inff,sizeof deep);
while(!q.empty()) q.pop();
q.push(s);deep[s]=0;
while(!q.empty()){
int nowp=q.front();q.pop();
for(int i=head[nowp];~i;i=edge[i].next){
if(deep[edge[i].to]==inff&&edge[i].dis){
deep[edge[i].to]=deep[nowp]+1;
q.push(edge[i].to);
}
}
}
return deep[t]!=inff;
}
int dfs(int nowp,int t,int lim){
if(nowp==t||lim==0) return lim;
int f,ret=0;
for(int i=cur[nowp];~i;i=edge[i].next){
cur[nowp]=i;
if(deep[edge[i].to]==deep[nowp]+1&&(f=dfs(edge[i].to,t,min(lim,edge[i].dis)))){
ret+=f,lim-=f;
edge[i].dis-=f,edge[i^1].dis+=f;
if(!lim) break;
}
}
return ret;
}
void dinic(int s,int t){
while(bfs(s,t)) ans+=dfs(s,t,inf);
}
int get_num(int x,bool fg){//fg==0 set fg==1 id
return fg*n+x;
}
int main(){
ll sum=0;
memset(head,-1,sizeof head);
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
}s=0,t=n+1;
for(int i=1;i<=n;i++){
scanf("%d",&val[i]);
}
for(int i=1;i<=n;i++){
if(val[i]>=0){
add(s,i,val[i]);sum+=val[i];
}
else add(i,t,-val[i]);
}
for(int i=1;i<=n;i++){
mem(mapp);
for(int j=i-1;j>=1;j--){
if(a[i]%a[j]==0&&!mapp[a[j]]) {
add(i,j,inf) ;
mapp[a[j]]=1;
}
}
}
dinic(s,t);
//cout<<anss<<endl;
printf("%lld\n",sum-ans);
}//？
| 6 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, t, uu, mas[5003], dp[5003], liel, k;
double a;
int bins(int l, int r, int y) {
int c = r - (r - l) / 2;
if (l < r) {
if (dp[c] <= y) {
return bins(c, r, y);
} else {
return bins(l, c - 1, y);
}
} else {
if (dp[l] > y) {
return 0;
} else {
return l;
}
}
}
int main() {
std::cin.sync_with_stdio(false);
cin >> n >> m;
i = 0;
while (i < n) {
cin >> mas[i] >> a;
i++;
}
i = 0;
while (i < 5003) {
dp[i] = 1000000007;
i++;
}
dp[1] = mas[0];
liel = 1;
i = 1;
while (i < n) {
k = bins(1, liel, mas[i]) + 1;
dp[k] = mas[i];
liel = max(liel, k);
i++;
}
i = 1;
while (i <= n && dp[i] < 1000000007) {
i++;
}
cout << n - (i - 1) << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,d;
cin >> d >> n;
int ans = pow(100,d)*n;
if (n==100) ans += pow(100,d);
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
void accell() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
}
const long long N = (1 << 17);
vector<pair<long long, long long> > g[N];
const long long LG = 18;
struct node {
node *l, *r;
long long mx1, mx2;
long long add;
node(long long key) {
mx1 = key;
mx2 = -1e18;
add = 0;
l = r = nullptr;
}
};
long long lvl[N];
long long p[N];
long long slave[N][LG];
multiset<long long> answ;
vector<pair<long long, long long> > vec[N];
long long h[N][LG];
long long sv[N][LG];
long long lf[N][LG];
long long rg[N][LG];
node *t[N];
multiset<long long> rep[N];
void push(node *v) {
if (v->l) v->l->add += v->add, v->l->mx1 += v->add, v->l->mx2 += v->add;
if (v->r) v->r->add += v->add, v->r->mx1 += v->add, v->r->mx2 += v->add;
v->add = 0;
}
pair<long long, long long> merge(node *l, node *r) {
if (l->mx1 < r->mx1) swap(l, r);
pair<long long, long long> res;
res.first = l->mx1;
res.second = max(l->mx2, r->mx1);
return res;
}
node *build_seg(node *v, long long tl, long long tr, vector<long long> &a) {
if (!v) v = new node(0);
if (tl == tr) {
v = new node(a[tl]);
return v;
}
long long tm = tl + tr >> 1;
v->l = build_seg(v->l, tl, tm, a);
v->r = build_seg(v->r, tm + 1, tr, a);
pair<long long, long long> x = merge(v->l, v->r);
v->mx1 = x.first;
v->mx2 = x.second;
return v;
}
pair<long long, long long> get(node *v, long long tl, long long tr, long long l,
long long r) {
if (tl > r || tr < l) return {0LL, -1e18};
if (l <= tl && tr <= r) return {v->mx1, v->mx2};
push(v);
long long tm = tl + tr >> 1;
pair<long long, long long> x = get(v->l, tl, tm, l, r);
pair<long long, long long> y = get(v->r, tm + 1, tr, l, r);
if (x.first < y.first) swap(x, y);
pair<long long, long long> res = {x.first, max(x.second, y.first)};
return res;
}
node *modify(node *v, long long tl, long long tr, long long l, long long r,
long long val) {
if (tl > r || tr < l) return v;
if (l <= tl && tr <= r) {
v->mx1 += val;
v->mx2 += val;
v->add += val;
return v;
}
push(v);
long long tm = tl + tr >> 1;
v->l = modify(v->l, tl, tm, l, r, val);
v->r = modify(v->r, tm + 1, tr, l, r, val);
pair<long long, long long> x = merge(v->l, v->r);
v->mx1 = x.first;
v->mx2 = x.second;
return v;
}
long long find_cent(long long v, long long sz, long long ¢,
long long par = -1) {
long long s = 1;
for (auto to : g[v]) {
if (to.first != par && lvl[to.first] == -1)
s += find_cent(to.first, sz, cent, v);
}
if (cent == -1 && (2 * s >= sz || par == -1)) cent = v;
return s;
}
void zhfs(long long v, long long st, long long cc, vector<long long> &a,
long long dist = 0, long long par = -1) {
lf[v][st] = 1e9;
rg[v][st] = 0;
slave[v][st] = cc;
for (auto to : g[v]) {
if (to.first != par && lvl[to.first] == -1) {
h[to.first][st] = h[v][st] + 1;
zhfs(to.first, st, cc, a, dist + to.second, v);
sv[v][st] += sv[to.first][st];
lf[v][st] = min(lf[to.first][st], lf[v][st]);
rg[v][st] = max(rg[v][st], rg[to.first][st]);
}
}
long long cnt1 = 0;
for (auto to : g[v]) {
if (to.first != par && lvl[to.first] == -1) cnt1++;
}
if (cnt1 == 0) {
a.push_back(dist);
lf[v][st] = (long long)a.size() - 1;
sv[v][st] += 1;
rg[v][st] = (long long)a.size() - 1;
}
}
void build(long long v, long long sz, long long d = 0, long long par = -1) {
long long cent = -1;
find_cent(v, sz, cent, -1);
vector<long long> a;
zhfs(cent, d, cent, a, 0, -1);
t[cent] = new node(0);
t[cent] = build_seg(t[cent], 0, (long long)a.size() - 1, a);
for (auto to : g[cent]) {
if (lvl[to.first] == -1) {
vec[cent].push_back({rg[to.first][d], lf[to.first][d]});
}
}
sort(vec[cent].begin(), vec[cent].end());
for (long long i = 0; i < vec[cent].size(); ++i) {
rep[cent].insert(-get(t[cent], 0, (long long)a.size() - 1,
vec[cent][i].second, vec[cent][i].first)
.first);
}
lvl[cent] = d;
p[cent] = par;
if (rep[cent].size() > 0) {
long long rs = 0;
auto it = rep[cent].begin();
rs += -(*it);
if (rep[cent].size() > 1) {
it++;
rs += -(*it);
}
answ.insert(rs);
}
for (auto to : g[cent]) {
if (lvl[to.first] == -1) build(to.first, sz / 2, d + 1, cent);
}
}
void upd(long long a, long long b, long long dw) {
if (lvl[a] < lvl[b]) {
swap(a, b);
}
long long c = a;
long long d = b;
while (lvl[c] != lvl[d]) {
c = p[c];
}
while (c != d) {
c = p[c];
d = p[d];
}
long long cent = c;
while (cent != -1) {
long long sz = sv[cent][lvl[cent]];
long long cl = lvl[cent];
if (h[a][cl] > h[b][cl]) swap(a, b);
pair<long long, long long> aa = {lf[b][cl], -1};
long long id =
lower_bound(vec[cent].begin(), vec[cent].end(), aa) - vec[cent].begin();
long long lef = vec[cent][id].second;
long long rig = vec[cent][id].first;
long long a1 = get(t[cent], 0, sz - 1, lef, rig).first;
auto it = rep[cent].begin();
long long kek = -(*it);
if (rep[cent].size() > 1) {
++it;
kek += -(*it);
}
rep[cent].erase(rep[cent].find(-a1));
answ.erase(answ.find(kek));
modify(t[cent], 0, sz - 1, lf[b][cl], rg[b][cl], dw);
a1 = get(t[cent], 0, sz - 1, lef, rig).first;
rep[cent].insert(-a1);
it = rep[cent].begin();
kek = -(*it);
if (rep[cent].size() > 1) {
++it;
kek += -(*it);
}
answ.insert(kek);
cent = p[cent];
}
}
signed main() {
srand(time(0));
accell();
fill(lvl, lvl + N, -1);
long long n, q, w;
cin >> n >> q >> w;
vector<pair<pair<long long, long long>, long long> > edge;
for (long long i = 1; i < n; ++i) {
long long a, b, c;
cin >> a >> b >> c;
--a, --b;
g[a].push_back({b, c});
g[b].push_back({a, c});
edge.push_back({{a, b}, c});
}
build(0, n, 0, -1);
long long ls = 0;
while (q--) {
long long dd, ee;
cin >> dd >> ee;
dd = (dd + ls) % (n - 1);
ee = (ee + ls) % w;
long long a = edge[dd].first.first;
long long b = edge[dd].first.second;
long long del = ee - edge[dd].second;
edge[dd].second = ee;
upd(a, b, del);
if (answ.size() == 0) {
cout << "EMPTY";
return 0;
}
cout << (*answ.rbegin()) << '\n';
ls = *answ.rbegin();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
if (2*k > n+1) {
cout << -1 << endl;
return 0;
}
int d = (n+1)/2 - k;
for (int i = 0; i < (n+1)/2; ++i) {
cout << (k+2*i) << " " << (2*n-i - d) << " " << (k + 2*n + i) << "\n";
}
for (int i = 0; i < (n-1)/2; ++i) {
cout << (k + 2*i + 1) << " " << (2*n + (n-1)/2 - i - d) << " " << (k + 2*n + (n+1)/2 + i) << "\n";
}
if (n % 2 == 0) {
cout << (k+n-1) << " " << (k+n) << " " << (k+3*n-1) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 100100;
double a[SIZE];
pair<double, double> tree[4 * SIZE];
int n, q, gl, gr;
pair<double, double> merge(pair<double, double> p1, pair<double, double> p2) {
return {(p1.first * p2.first) / (1 - (1 - p2.first) * p1.second),
p2.second + (1 - p2.second) * p1.second * p2.first /
(1 - (1 - p2.first) * p1.second)};
}
void build(int node, int ll, int lr) {
if (ll > lr) return;
if (ll == lr) {
tree[node] = {a[ll], a[ll]};
return;
}
build(node * 2, ll, (ll + lr) / 2);
build(node * 2 + 1, 1 + (ll + lr) / 2, lr);
tree[node] = merge({tree[node * 2].first, tree[node * 2].second},
{tree[node * 2 + 1].first, tree[node * 2 + 1].second});
}
void update(int node, int ll, int lr, double value) {
if (ll > lr || ll > gr || lr < gl) return;
if (ll == lr) {
tree[node] = {value, value};
return;
}
update(node * 2, ll, (ll + lr) / 2, value);
update(node * 2 + 1, (ll + lr) / 2 + 1, lr, value);
tree[node] = merge({tree[node * 2].first, tree[node * 2].second},
{tree[node * 2 + 1].first, tree[node * 2 + 1].second});
}
pair<double, double> query(int node, int ll, int lr) {
if (ll > lr || ll > gr || lr < gl) return {1, 0};
if (ll >= gl && lr <= gr) return tree[node];
return merge(query(node * 2, ll, (ll + lr) / 2),
query(node * 2 + 1, 1 + (ll + lr) / 2, lr));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
cin >> n >> q;
int x, y, type;
for (int i = 0; i < n; i++) cin >> x >> y, a[i] = double(x) / y;
build(1, 0, n - 1);
while (q--) {
cin >> type;
if (type == 1) {
cin >> gl;
gl--;
gr = gl;
cin >> x >> y;
update(1, 0, n - 1, double(x) / y);
} else {
cin >> gl >> gr;
gl--, gr--;
cout << query(1, 0, n - 1).first << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long MAX = 1000000000000;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int nn, mm;
std::cin >> nn >> mm;
std::vector<std::vector<long long>> horiz(nn, std::vector<long long>(mm - 1));
std::vector<std::vector<long long>> vert(nn, std::vector<long long>(mm));
for (int j = 0; j < mm - 1; ++j) {
for (int i = 0; i < nn; ++i) std::cin >> horiz[i][j];
}
for (int j = 0; j < mm; ++j) {
for (int i = 0; i < nn; ++i) std::cin >> vert[i][j];
}
int masks = 1 << nn;
std::vector<long long> prev(1 << nn, MAX);
std::vector<long long> next(1 << nn, 0);
prev[0] = 0;
for (int kk = 0; kk < mm - 1; ++kk) {
next.assign(1 << nn, MAX);
for (int ii = 0; ii < masks; ++ii) {
long long vertcut = 0;
for (int ll = 0; ll < nn - 1; ++ll) {
if (((ii >> ll) & 1) ^ ((ii >> (ll + 1)) & 1))
vertcut += vert[ll][kk + 1];
}
if (((ii >> (nn - 1)) & 1) ^ (ii & 1)) vertcut += vert[nn - 1][kk + 1];
long long horcut = MAX;
for (int jj = 0; jj < masks; ++jj) {
long long cut = 0;
for (int ll = 0; ll < nn; ++ll) {
if (((ii >> ll) & 1) ^ ((jj >> ll) & 1)) {
cut += horiz[ll][kk];
}
}
horcut = std::min(horcut, cut + prev[jj]);
}
next[ii] = horcut + vertcut;
}
prev = next;
}
std::cout << next[masks - 1] << std::endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
int a[18];
long long ct;
int max1;
int ans = 0;
cin >> n;
while (n) {
ct = n;
max1 = 0;
for (int i = 0; ct != 0; ++i) {
a[i] = ct % 10;
ct = ct / 10;
if (max1 < a[i]) max1 = a[i];
}
n -= max1;
ans++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long) 1e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector< vector< pair<int, int> > > g(n + 1);
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
long long dist[n + 1][2][2];
for (int i = 1; i <= n; i++) {
for (int b1 = 0; b1 < 2; b1++) {
for (int b2 = 0; b2 < 2; b2++) {
dist[i][b1][b2] = INF;
}
}
}
dist[1][0][0] = 0;
priority_queue< tuple<long long, int, int, int>, vector< tuple<long long, int, int, int> >, greater< tuple<long long, int, int, int> > > pq; pq.push({0, 1, 0, 0});
while (!pq.empty()) {
int u = get<1>(pq.top()), b1 = get<2>(pq.top()), b2 = get<3>(pq.top());
long long d = get<0>(pq.top());
pq.pop();
if (d > dist[u][b1][b2]) continue;
for (auto& v : g[u]) {
if (d + (long long) v.second < dist[v.first][b1][b2]) {
dist[v.first][b1][b2] = d + (long long) v.second;
pq.push({dist[v.first][b1][b2], v.first, b1, b2});
}
if (!b1) {
if (d < dist[v.first][1][b2]) {
dist[v.first][1][b2] = d;
pq.push({dist[v.first][1][b2], v.first, 1, b2});
}
}
if (!b2) {
if (d + 2ll * v.second < dist[v.first][b1][1]) {
dist[v.first][b1][1] = d + 2ll * v.second;
pq.push({dist[v.first][b1][1], v.first, b1, 1});
}
}
if (!b1 && !b2) {
if (d + (long long) v.second < dist[v.first][1][1]) {
dist[v.first][1][1] = d + (long long) v.second;
pq.push({dist[v.first][1][1], v.first, 1, 1});
}
}
}
}
for (int i = 2; i <= n; i++) cout << dist[i][1][1] << ' ';
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
bool mark[100005];
vector<int> adj[100005];
int dfs(int nd) {
if (mark[nd]) return 0;
mark[nd] = 1;
int ret = 1;
for (int i = 0; i < adj[nd].size(); i++) {
int ch = adj[nd][i];
ret += dfs(ch);
}
return ret;
}
int main() {
scanf("%d", &N);
scanf("%d", &M);
scanf("%d", &K);
for (int i = 0; i < M; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
long long ans = 1, cmp = 0;
for (int i = 1; i <= N; i++)
if (!mark[i]) {
ans = (ans * dfs(i)) % K;
cmp++;
}
for (int i = 1; i <= cmp - 2; i++) ans = (ans * N) % K;
if (cmp == 1) ans = 1 % K;
cout << ans << endl;
}
| 4 |
#include<cstdio>
#include<iostream>
#include<vector>
#include<map>
#include<queue>
#include<algorithm>
#include<string.h>
#include<math.h>
#define mod 1000000007
#define eps 1e-10
using namespace std;
struct node
{
int m,d,h,min,st,v;
};
node re[1002];
int vis[1002];
int ans[1002];
int cal(int h1,int min1,int h2,int min2)
{
return h2*60+min2-(h1*60+min1);
}
int main()
{
int n;
while(scanf("%d",&n),n)
{
int m,d,h,min,v;
char st;int ma=0;
memset(vis,0,sizeof(vis));
memset(ans,0,sizeof(ans));
for(int i=1;i<=n;i++)
{
scanf("%d%*c%d%d%*c%d%*c%c%d",&m,&d,&h,&min,&st,&v);
ma=max(ma,v);
re[i].m=m;re[i].d=d;re[i].h=h;re[i].min=min;re[i].v=v;
if(st=='I') re[i].st=1;else re[i].st=0;
}
int cm=re[1].m,cd=re[1].d,f=0;
for(int i=1;i<=n;i++)
{
if(cm==re[i].m&&cd==re[i].d)
{
if(re[i].v!=0&&re[i].st==1) vis[re[i].v]=i;
if(re[i].v!=0&&re[i].st==0) if(vis[re[i].v]!=0&&f!=0)
{
int u=vis[re[i].v];//cout<<i<<" "<<u<<endl;
ans[re[i].v]+=cal(re[u].h,re[u].min,re[i].h,re[i].min);
vis[re[i].v]=0;
}
if(re[i].v!=0&&re[i].st==0) vis[re[i].v]=0;
if(re[i].v==0&&re[i].st==1)
{
f=i;
for(int j=1;j<=ma;j++) if(vis[j]!=0)
{
re[vis[j]].h=re[i].h;re[vis[j]].min=re[i].min;
}
}
if(re[i].v==0&&re[i].st==0)
{
f=0;
for(int j=1;j<=ma;j++) if(vis[j]!=0)
{
ans[j]+=cal(re[vis[j]].h,re[vis[j]].min,re[i].h,re[i].min);
}
}
}
else
{
memset(vis,0,sizeof(vis));
cm=re[i].m;cd=re[i].d;i--;
}
}
int an=0;
for(int i=1;i<=ma;i++)
an=max(an,ans[i]);
printf("%d\n",an);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void OPEN(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
struct point {
double x, y;
point() { x = y = 0; }
point(double x, double y) : x(x), y(y) {}
};
struct segment {
point p1, p2;
segment() { p1 = p2 = point(0, 0); }
segment(point p1, point p2) : p1(p1), p2(p2) {}
};
point operator-(const point &p1, const point &p2) {
return point(p1.x - p2.x, p1.y - p2.y);
}
point operator+(const point &p1, const point &p2) {
return point(p1.x + p2.x, p1.y + p2.y);
}
point operator*(const point &p, const double &s) {
return point(p.x * s, p.y * s);
}
point operator/(const point &p, const double &s) { return p * (1. / s); }
bool operator<(const point &p1, const point &p2) {
if (p1.x != p2.x) return p1.x < p2.x;
return p1.y < p2.y;
}
bool operator==(const point &p1, const point &p2) {
return fabs(p1.x - p2.x) < 1e-9 && fabs(p1.y - p2.y) < 1e-9;
}
double dist(const point &p) { return sqrt(((p.x) * (p.x)) + ((p.y) * (p.y))); }
double dist(const point &p1, const point &p2) {
return sqrt(((p1.x - p2.x) * (p1.x - p2.x)) +
((p1.y - p2.y) * (p1.y - p2.y)));
}
double cross(const point &p1, const point &p2) {
return p1.x * p2.y - p1.y * p2.x;
}
double distToLine(const point &p, const segment &s) {
return fabs(cross(s.p1 - p, s.p2 - p)) / dist(s.p1, s.p2);
}
double x, y, yl, yh, yw, xb, yb, r;
int check(double xw) {
double xlo = 2. * xw - xb;
double m = (yb - yw) / (xlo - xw);
double yy = yw - m * xw;
if (yy < yl) return 0;
return 1;
}
int check2(double xw) {
double xlo = 2. * xw - xb;
double m = (yb - yw) / (xlo - xw);
double yy = yw - m * xw;
segment seg(point(0, yy), point(xw, yw));
point p(0, yh);
if (distToLine(p, seg) < r) return 0;
return 1;
}
int main() {
scanf("%lf %lf %lf %lf %lf %lf", &yl, &yh, &yw, &xb, &yb, &r);
yw -= r;
yl += r;
double le = 0., ri = xb - 1e-9;
for (int bs = 0; bs < 1000000 && le < ri; bs++) {
double piv = (le + ri + 1e-9) / 2.;
if (check(piv))
le = piv;
else
ri = piv - 1e-9;
}
if (check(le) == 1 && check2(le) == 1) {
printf("%.10lf\n", le);
} else {
printf("-1\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
pair<ll,ll>p[214514];
int main() {
ll n;
cin>>n;
for(int i=0;i<n;i++)cin>>p[i].second>>p[i].first;
sort(p,p+n);
ll cnt=0;
for(int i=0;i<n;i++){
if(cnt+p[i].second>p[i].first){
cout<<"No"<<endl;
return 0;
}
cnt+=p[i].second;
}
cout<<"Yes"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,k;
cin>>n>>k;
int h[n],f[n];
f[n-1] = 0;
for(int i=0;i<n;i++)
{
cin>>h[i];
}
for(int i=n-2;i>=0;i--)
{
f[i]=INT_MAX;
for(int j=i+1;j<=min(n-1,i+k);j++)
{
f[i] = min(f[j]+abs(h[i]-h[j]),f[i]);
}
}
cout<<f[0]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long ori[100010], f[100010][4];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) scanf("%I64d", &ori[i]);
long long ans = 0;
for (int i = 1; i <= n - 1; i++)
for (int j = 0; j <= 3; j++) {
if (j == 0) {
if ((ori[i] & 1) ? ori[i] - 1 : ori[i])
f[i + 1][1] = max(f[i + 1][1], (ori[i] & 1) ? ori[i] - 1 : ori[i]);
f[i + 1][2] = max(f[i + 1][2], (ori[i] & 1) ? ori[i] : ori[i] - 1);
if ((ori[i] & 1) ? ori[i] - 1 : ori[i])
f[i + 1][3] = max(f[i + 1][3], (ori[i] & 1) ? ori[i] - 1 : ori[i]);
for (int k = 1; k <= 3; k++) ans = max(ans, f[i + 1][k]);
} else if (j == 1) {
if ((ori[i] & 1) ? ori[i] - 1 : ori[i])
f[i + 1][1] =
max(f[i + 1][1], f[i][j] + ((ori[i] & 1) ? ori[i] - 1 : ori[i]));
f[i + 1][2] =
max(f[i + 1][2], f[i][j] + ((ori[i] & 1) ? ori[i] : ori[i] - 1));
if ((ori[i] & 1) ? ori[i] - 1 : ori[i])
f[i + 1][3] =
max(f[i + 1][3], f[i][j] + ((ori[i] & 1) ? ori[i] - 1 : ori[i]));
for (int k = 1; k <= 3; k++) ans = max(ans, f[i + 1][k]);
} else if (j == 2) {
f[i + 1][2] =
max(f[i + 1][2], f[i][j] + ((ori[i] & 1) ? ori[i] : ori[i] - 1));
if ((ori[i] & 1) ? ori[i] - 1 : ori[i])
f[i + 1][3] =
max(f[i + 1][3], f[i][j] + ((ori[i] & 1) ? ori[i] - 1 : ori[i]));
for (int k = 2; k <= 3; k++) ans = max(ans, f[i + 1][k]);
} else if (j == 3) {
if ((ori[i] & 1) ? ori[i] - 1 : ori[i])
f[i + 1][3] =
max(f[i + 1][3], f[i][j] + ((ori[i] & 1) ? ori[i] - 1 : ori[i]));
ans = max(ans, f[i + 1][3]);
}
}
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long INF = mod * mod;
const long double eps = 1e-12;
const long double pi = acos(-1.0);
long long mod_pow(long long a, long long n, long long m = mod) {
long long res = 1;
while (n) {
if (n & 1) res = res * a % m;
a = a * a % m;
n >>= 1;
}
return res;
}
struct modint {
long long n;
modint() : n(0) { ; }
modint(long long m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
a.n += b.n;
if (a.n >= mod) a.n -= mod;
return a;
}
modint operator-=(modint &a, modint b) {
a.n -= b.n;
if (a.n < 0) a.n += mod;
return a;
}
modint operator*=(modint &a, modint b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0) return modint(1);
modint res = (a * a) ^ (n / 2);
if (n % 2) res = res * a;
return res;
}
long long inv(long long a, long long p) {
return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 10000;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int nex[1 << 20];
bool isw[1 << 20];
vector<int> rG[1 << 20];
void solve() {
int h, w;
cin >> h >> w;
for (int i = 0; i < h * w; i++) rG[i].clear();
int ans1 = 0, ans2 = 0;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) {
char c;
cin >> c;
isw[i * w + j] = (c == '1');
}
for (int i = 0; i < h * w; i++) {
char c;
cin >> c;
if (c == 'R') {
nex[i] = i + 1;
rG[i + 1].push_back(i);
} else if (c == 'L') {
nex[i] = i - 1;
rG[i - 1].push_back(i);
} else if (c == 'U') {
nex[i] = i - w;
rG[i - w].push_back(i);
} else {
nex[i] = i + w;
rG[i + w].push_back(i);
}
}
vector<bool> used(h * w, false);
for (int i = 0; i < h * w; i++) {
if (used[i]) continue;
stack<int> st;
int cur = i;
while (!used[cur]) {
used[cur] = true;
st.push(cur);
cur = nex[cur];
}
vector<int> loop;
loop.push_back(cur);
while (st.top() != cur) {
loop.push_back(st.top());
st.pop();
}
reverse((loop).begin(), (loop).end());
vector<bool> exi(loop.size(), false);
queue<pair<int, int> > q;
for (int j = 0; j < loop.size(); j++) {
if (!isw[loop[j]]) exi[j] = true;
int pre;
if (j == 0)
pre = loop.back();
else
pre = loop[j - 1];
for (int to : rG[loop[j]])
if (to != pre) {
q.push({to, j - 1});
}
}
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int id = p.first;
used[id] = true;
if (p.second < 0) p.second += loop.size();
if (!isw[id]) exi[p.second] = true;
for (int to : rG[id]) {
q.push({to, p.second - 1});
}
}
ans1 += loop.size();
for (int j = 0; j < exi.size(); j++)
if (exi[j]) ans2++;
}
cout << ans1 << " " << ans2 << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) solve();
char nyaa;
cin >> nyaa;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int k, i, j, x, s, q;
char c[9];
int mii = 100000000;
vector<vector<int> > digit(9, vector<int>());
vector<vector<int> > res(9, vector<int>());
vector<int> mask(9);
int sum(vector<vector<int> > arr) {
int mmin = 100000000;
int mmax = 0;
int x, i, j, q;
for (i = 0; i < n; i++) {
x = 0;
for (j = k - 1, q = 1; j >= 0; j--, q *= 10) {
x += q * arr[i][j];
}
if (x < mmin) mmin = x;
if (x > mmax) mmax = x;
}
return mmax - mmin;
}
void permute(vector<vector<int> > arr, vector<int> mask, int x) {
int l;
for (int j = 0; j < k; j++) {
if (!mask[j]) {
mask[j] = 1;
for (int q = 0; q < n; q++) {
arr[q][x] = digit[q][j];
}
if (x == k - 1) {
l = sum(arr);
if (l < mii) mii = l;
} else {
permute(arr, mask, x + 1);
}
mask[j] = 0;
}
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%s", &c);
for (j = 0; j < k; ++j) {
digit[i].push_back(c[j] - '0');
}
}
permute(digit, mask, 0);
printf("%d\n", mii);
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string N;int K;cin>>N>>K;
vector<vector<long>> DP(N.length(),vector<long>(4,0));
DP[0][0]=1;
DP[0][1]=(int)N[0]-48;
int c=1;
for(int i=1;i<N.length();i++){
DP[i][0]=1;
for(int j=1;j<=3;j++){
DP[i][j]=DP[i-1][j]+DP[i-1][j-1]*9-(c+1==j?9-((int)N[i]-48):0);
}
if((int)N[i]-48!=0)c++;
}
cout<<DP[N.length()-1][K];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int ax, ay, bx, by, cx, cy;
cin >> ax >> ay >> bx >> by >> cx >> cy;
long long int x1 = ax - bx;
long long int x2 = cx - bx;
if ((bx < ax && ax < cx) || (cx < ax && ax < bx) || (by < ay && ay < cy) ||
(cy < ay && ay < by))
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
switch (n % 4) {
case 0:
printf("0\n%d ", n / 2);
for (int i = 0; i < n / 4; i++) {
printf("%d %d ", 1 + i * 4, 4 + i * 4);
}
break;
case 1:
n--;
printf("1\n%d 1 ", n / 2 + 1);
for (int i = 0; i < n / 4; i++) {
printf("%d %d ", 2 + i * 4, 5 + i * 4);
}
break;
case 2:
n -= 2;
printf("1\n%d 1 ", n / 2 + 1);
for (int i = 0; i < n / 4; i++) {
printf("%d %d ", 3 + i * 4, 6 + i * 4);
}
break;
case 3:
n -= 3;
printf("0\n%d 1 2 ", n / 2 + 2);
for (int i = 0; i < n / 4; i++) {
printf("%d %d ", 4 + i * 4, 7 + i * 4);
}
break;
default:
break;
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[26], ans;
int n, j, used[26];
bool f = true;
string s, s2;
void dfs(int l) {
if (used[l] == 1) f = false;
if (used[l]) return;
used[l] = 1;
for (int i = 0; i < g[l].size(); ++i) dfs(g[l][i]);
used[l] = 2;
ans.push_back(l);
}
int main() {
cin >> n;
cin >> s;
int first = s[0] - 'a';
for (int i = 1; i < n && f; ++i) {
cin >> s2;
for (j = 0; j < s.size() && j < s2.size(); ++j) {
if (s[j] != s2[j]) {
g[s[j] - 'a'].push_back(s2[j] - 'a');
break;
}
}
if (j == s2.size()) f = false;
s = s2;
}
for (int i = 0; i < 26; ++i) dfs(i);
if (f) {
for (int i = 25; i >= 0; --i) cout << (char)('a' + ans[i]);
} else
cout << "Impossible";
return 0;
}
| 3 |
//18
#include<iostream>
using namespace std;
int main(){
bool ns=false;
for(int n;cin>>n;){
char a[8][6]={{}};
for(int i=4;i>=0;i--,n/=10){
int m=n%10;
a[0][i]=(m>=5)?' ':'*';
a[1][i]=(m>=5)?'*':' ';
a[2][i]='=';
for(int j=0;j<5;j++){
a[3+j][i]=(m%5==j)?' ':'*';
}
}
if(ns){
cout<<endl;
}
for(int i=0;i<8;i++){
cout<<a[i]<<endl;
}
ns=true;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, tot, nr1, nr;
string s;
bool Ok[200005];
vector<long long> V[200005];
long long gcd(long long a, long long b) {
while (b) {
long long r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> s;
for (long long i = 1; i < n; i++) {
if (n % i == 0) {
for (long long k = 0; k < s.size(); k += i) {
V[k].clear();
for (long long j = k; j < k + i; j++) {
V[k].push_back(s[j] - '0');
}
}
long long ok = 1;
for (long long j = 0; j < i; j++) {
long long ans = 0;
for (long long k = 0; k < s.size(); k += i) {
ans ^= V[k][j];
}
if (ans != 0) {
ok = 0;
break;
}
}
if (ok) {
Ok[i] = 1;
}
}
}
for (long long i = 1; i < n; i++) {
nr += Ok[gcd(i, n)];
}
for (auto i : s) nr1 += (i == '1');
if (tot == 0)
cout << nr + (nr1 == 0);
else
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> g[100005], gg[100005], v[100005], down[100005][17];
long long n, root, cnt, q, ans;
long long cc[100005], c[100005], ne[100005], depth[100005], childdepth[100005];
long long up[100005][17], val[100005][17], lefty[100005][17],
righty[100005][17];
long long segtree[17][400005], ltree[17][400005], rtree[17][400005];
void label(long long u, long long p, long long d) {
v[d].push_back(u);
for (auto vv : gg[u])
if (vv != p) label(vv, u, d + 1);
}
void dfs(long long u, long long p) {
depth[u] = depth[p] + 1;
childdepth[u] = depth[u];
up[u][0] = p;
down[p][0].push_back(u);
val[p][0] = min(val[p][0], c[u]);
lefty[p][0] = min(lefty[p][0], u);
righty[p][0] = max(righty[p][0], u);
for (long long i = 1; i <= 16; i++) {
up[u][i] = up[up[u][i - 1]][i - 1];
lefty[up[u][i]][i] = min(lefty[up[u][i]][i], u);
righty[up[u][i]][i] = max(righty[up[u][i]][i], u);
down[up[u][i]][i].push_back(u);
}
for (auto v : g[u])
if (v != p) {
dfs(v, u);
childdepth[u] = max(childdepth[u], childdepth[v]);
}
}
void build(long long id, long long l, long long r) {
if (l == r) {
for (long long i = 0; i <= 16; i++) {
segtree[i][id] = val[l][i];
ltree[i][id] = lefty[l][i];
rtree[i][id] = righty[l][i];
}
return;
}
long long m = (l + r) / 2;
build(id * 2, l, m);
build(id * 2 + 1, m + 1, r);
for (long long i = 0; i <= 16; i++) {
segtree[i][id] = min(segtree[i][id * 2], segtree[i][id * 2 + 1]);
ltree[i][id] = min(ltree[i][id * 2], ltree[i][id * 2 + 1]);
rtree[i][id] = max(rtree[i][id * 2], rtree[i][id * 2 + 1]);
}
}
long long get_min(long long id, long long l, long long r, long long tl,
long long tr, long long bit) {
if (l > tr || r < tl) return 1000000000000000000;
if (l >= tl && r <= tr) return segtree[bit][id];
long long m = (l + r) / 2;
return min(get_min(id * 2, l, m, tl, tr, bit),
get_min(id * 2 + 1, m + 1, r, tl, tr, bit));
}
long long get_l(long long id, long long l, long long r, long long tl,
long long tr, long long bit) {
if (l > tr || r < tl) return 1000000000000000000;
if (l >= tl && r <= tr) return ltree[bit][id];
long long m = (l + r) / 2;
return min(get_l(id * 2, l, m, tl, tr, bit),
get_l(id * 2 + 1, m + 1, r, tl, tr, bit));
}
long long get_r(long long id, long long l, long long r, long long tl,
long long tr, long long bit) {
if (l > tr || r < tl) return 0;
if (l >= tl && r <= tr) return rtree[bit][id];
long long m = (l + r) / 2;
return max(get_r(id * 2, l, m, tl, tr, bit),
get_r(id * 2 + 1, m + 1, r, tl, tr, bit));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> root;
for (long long i = 1; i <= n; i++) cin >> cc[i];
for (long long i = 1; i <= n - 1; i++) {
long long a, b;
cin >> a >> b;
gg[a].push_back(b);
gg[b].push_back(a);
}
label(root, 0, 1);
for (long long i = 1; i <= 100000; i++) {
for (auto j : v[i]) ne[j] = ++cnt;
}
for (long long i = 1; i <= n; i++) c[ne[i]] = cc[i];
for (long long i = 1; i <= n; i++) {
for (auto &j : gg[i]) j = ne[j];
}
for (long long i = 1; i <= n; i++) g[ne[i]] = gg[i];
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= 16; j++) {
val[i][j] = 1000000000000000000;
lefty[i][j] = 1000000000000000000;
}
}
dfs(1, 0);
for (long long j = 1; j <= 16; j++) {
for (long long i = n; i >= 1; i--) {
long long r = 1000000000000000000;
for (auto v : down[i][j - 1]) r = min(r, val[v][j - 1]);
val[i][j] = min(r, val[i][j - 1]);
}
}
build(1, 1, n);
cin >> q;
while (q--) {
long long x, k;
cin >> x >> k;
x = (x + ans) % n + 1;
k = (k + ans) % n;
x = ne[x];
k = min(k, childdepth[x] - depth[x]);
ans = c[x];
long long curl = x, curr = x;
for (long long i = 16; i >= 0; i--)
if ((1 << i) <= k) {
k -= (1 << i);
ans = min(ans, get_min(1, 1, n, curl, curr, i));
long long tl = get_l(1, 1, n, curl, curr, i);
long long tr = get_r(1, 1, n, curl, curr, i);
curl = tl;
curr = tr;
}
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, temp;
cin >> a >> b;
if (a > b) {
temp = a;
a = b;
b = temp;
}
cout << a;
b = b - a;
if (b > 1) {
cout << " " << b / 2;
} else {
cout << " "
<< "0";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,total=0;
cin>>n;
int a[n+1];
for(int i=1;i<=n;i++){
cin>>a[i];
}
sort(a+1,a+n+1);
for(int i=1;i<=n-2;i++)
for(int j=i+1;j<=n-1;j++)
for(int k=j+1;k<=n;k++)
if(a[i]+a[j]>a[k]) total++;
else break;
cout<<total<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
template <typename T>
inline void printVector(const T& a, int type = 0, int left = -1,
int right = -1) {
if (left != -1 && right != -1) {
for (int i = left; i < right; i++) {
cout << a[i] << " ";
if (type == 1) {
cout << endl;
}
}
if (type == 0) {
cout << endl;
}
return;
}
for (auto it : a) {
cout << it << " ";
if (type == 1) {
cout << endl;
}
}
if (type == 0) {
cout << endl;
}
}
template <typename T>
inline void printPairVector(const T& a, int left = -1, int right = -1) {
if (left != -1 && right != -1) {
for (int i = left; i < right; i++) {
cout << a[i].first << " " << a[i].second << endl;
}
return;
}
for (auto it : a) {
cout << it.first << " " << it.second << endl;
}
}
inline int charToInt(char c, char base = 'a') {
if (base == '-') {
return (int)c;
}
return (int)(c - base);
}
inline char intToChar(int i, char base = 'a') {
return (char)(i + charToInt(base, '-'));
}
inline void addMod(long long& a, long long b) {
a += b;
a %= mod;
}
inline void subMod(long long& a, long long b) {
a -= b;
if (a < 0) {
a += mod;
}
}
inline void mulMod(long long& a, long long b) {
a *= b;
a %= mod;
}
inline long long powerMod(long long a, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) {
mulMod(ans, a);
}
mulMod(a, a);
n >>= 1;
}
return ans;
}
inline long long powerNoMod(long long a, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) {
ans *= a;
}
a *= a;
n >>= 1;
}
return ans;
}
inline long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
inline long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
inline bool isEqualDouble(double a, double b, double epsilon = 0.0000001) {
return fabs(a - b) < epsilon;
}
inline void fact(vector<long long>& f) {
f[0] = 1LL;
for (int i = 1; i <= 1e6; i++) {
mulMod(f[i], (long long)i);
}
}
inline long long nCk(long long k, long long n) {
long long ans = 1;
k = max(k, n - k);
for (int i = 0; i < k; i++) {
ans *= (n - i);
ans /= (i + 1);
}
return ans;
}
inline long long nCk(const vector<long long>& f, int k, int n) {
if (k < 0 || k > n) {
return 0;
}
long long d = (f[k] * f[n - k]) % mod;
d = powerMod(d, (long long)mod - 2LL);
return (f[n] * d) % mod;
}
const int N = 2005, M = 2005;
int n, m, r, c, x, y;
vector<string> a;
int goLeft[N][M], goRight[N][M], used[N][M];
int dirx[] = {0, 0, -1, 1};
int diry[] = {-1, 1, 0, 0};
int ans = 0;
void bfs() {
queue<pair<int, int> > q;
q.push({r, c});
goLeft[r][c] = x;
goRight[r][c] = y;
while (!q.empty()) {
int u = q.front().first;
int v = q.front().second;
if (used[u][v]) {
q.pop();
continue;
}
used[u][v] = true;
q.pop();
for (int i = 0; i < 4; i++) {
int uu = u + dirx[i];
int vv = v + diry[i];
bool canGoLeft = (goLeft[u][v] >= 1);
bool canGoRight = (goRight[u][v] >= 1);
if (uu < 0 || uu == n || vv < 0 || vv == m || a[uu][vv] == '*') {
continue;
}
if (v > vv) {
if (!canGoLeft) {
continue;
}
if (used[uu][vv]) {
if (goLeft[u][v] - 1 > goLeft[uu][vv] ||
goRight[u][v] > goRight[uu][vv]) {
used[uu][vv] = false;
} else {
continue;
}
}
goLeft[uu][vv] = max(goLeft[u][v] - 1, goLeft[uu][vv]);
goRight[uu][vv] = max(goRight[uu][vv], goRight[u][v]);
} else if (v < vv) {
if (!canGoRight) {
continue;
}
if (used[uu][vv]) {
if (goLeft[u][v] > goLeft[uu][vv] ||
goRight[u][v] - 1 > goRight[uu][vv]) {
used[uu][vv] = false;
} else {
continue;
}
}
goLeft[uu][vv] = max(goLeft[u][v], goLeft[uu][vv]);
goRight[uu][vv] = max(goRight[u][v] - 1, goRight[uu][vv]);
} else {
if (used[uu][vv]) {
if (goLeft[u][v] > goLeft[uu][vv] ||
goRight[u][v] > goRight[uu][vv]) {
used[uu][vv] = false;
} else {
continue;
}
}
goLeft[uu][vv] = max(goLeft[u][v], goLeft[uu][vv]);
goRight[uu][vv] = max(goRight[u][v], goRight[uu][vv]);
}
q.push({uu, vv});
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> r >> c >> x >> y;
r--;
c--;
string s;
int i, j;
for (i = 0; i < n; i++) {
cin >> s;
a.push_back(s);
}
bfs();
int ans = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
ans += (int)used[i][j];
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> m;
vector<int> ans;
bool compare(vector<int> a, vector<int> b) { return a[0] < b[0]; }
int main() {
int n, d, a, b;
cin >> n >> d >> a >> b;
m.reserve(10000);
ans.reserve(100000);
for (int i = 0; i < n; i++) {
vector<int> row;
int xi, yi;
cin >> xi >> yi;
row.push_back(xi * a + yi * b);
row.push_back(i + 1);
m.push_back(row);
}
std::sort(m.begin(), m.end(), compare);
int counter = 0;
for (int i = 0; i < n; i++) {
int x = m.at(i).at(0);
if (d - x >= 0) {
d -= x;
counter++;
ans.push_back(m.at(i).at(1));
} else {
break;
}
}
cout << counter << '\n';
for (int i = 0; i < ans.size(); i++) {
cout << ans.at(i) << " ";
}
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e2 + 5;
int n, m;
int a[MAXN][MAXN];
void read_input()
{
scanf("%d %d", &n, &m);
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
scanf("%d", &a[i][j]);
a[i][j]--;
}
sort(a[i], a[i] + m);
}
}
bool used[MAXN];
int par[MAXN];
int k;
vector <int> graph[MAXN];
int tr[MAXN];
bool try_kuhn(int p)
{
if(used[p]) return false;
used[p] = true;
int z = graph[p].size();
for(int i = 0; i < z; i++)
{
int to = graph[p][i];
if(par[to] == -1 || try_kuhn(par[to]))
{
par[to] = p;
tr[p] = to;
return true;
}
}
return false;
}
bool mark[MAXN][MAXN];
int b1[MAXN][MAXN], b2[MAXN][MAXN];
void solve()
{
bool fl = true;
for(int z = 0; z < m; z++)
{
memset(par, -1, sizeof(par));
for(int i = 0; i < n; i++)
{
graph[i].clear();
for(int j = 0; j < m; j++)
{
if(!mark[i][j])
{
int temp = a[i][j] / m;
graph[i].push_back(temp);
}
}
}
for(int j = 0; j < n; j++)
{
memset(used, 0, sizeof(used));
fl &= try_kuhn(j);
}
for(int i = 0; i < n; i++)
{
int temp = tr[i];
for(int j = 0; j < m; j++)
{
if(a[i][j] / m == temp && !mark[i][j])
{
mark[i][j] = true;
b1[i][z] = a[i][j];
break;
}
}
}
}
if(!fl)
{
printf("DSA");
return;
}
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
printf("%d ", b1[i][j] + 1);
b2[j][i] = b1[i][j] + 1;
}
printf("\n");
}
for(int i = 0; i < m; i++)
{
sort(b2[i], b2[i] + n);
}
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m; j++)
{
printf("%d ", b2[j][i]);
}
printf("\n");
}
}
int main()
{
read_input();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> m;
long long diff[100005];
map<long long, long long> visit;
int main() {
long long n;
cin >> n;
long long a[100005] = {0};
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = n - 1; i >= 0; i--) {
if (m[a[i]] == 0) {
diff[i] = diff[i + 1] + 1;
m[a[i]]++;
} else {
m[a[i]]++;
diff[i] = diff[i + 1];
}
}
long long ans = 0;
for (long long i = 0; i < n - 1; i++) {
if (visit[a[i]] == 0) {
ans += diff[i + 1];
visit[a[i]] = 1;
}
}
cout << ans;
return 0;
}
| 3 |
#include <cstdio>
#include <algorithm>
#include <set>
#include <vector>
using namespace std;
int n, m;
int p[1000];
int ans;
vector<int> v;
void solve(){
ans = 0;
v.clear();
v.push_back(0);
for(int i = 0; i < n; i++){
scanf("%d", &p[i]);
if(p[i] <= m) v.push_back(p[i]);
}
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
if(p[i]+p[j] <= m) v.push_back(p[i]+p[j]);
}
}
sort(v.begin(),v.end());
int j = v.size()-1;
for(int i = 0; i < v.size(); i++){
while(true){
if(v[i]+v[j] <= m){
ans = max(ans,v[i]+v[j]);
break;
}
j--;
}
}
printf("%d\n", ans);
}
int main(){
while(scanf("%d%d", &n, &m),n||m) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long powm(long long base, long long exp, long long mod = 1000000007) {
base %= mod;
long long ans = 1;
while (exp) {
if (exp & 1LL) ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
long long a[2002][2002];
map<long long, long long> d1, d2;
long long b[2002][2002];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cin >> a[i][j];
}
for (int i = 1 - n; i <= n - 1; i++) {
int sx, sy;
if (i <= 0) {
sx = 1;
sy = 1 - i;
} else {
sx = 1 + i;
sy = 1;
}
long long k = 0;
for (int j = 0; sx + j <= n && sy + j <= n; j++) {
k += a[sx + j][sy + j];
}
d1[i] = k;
}
for (int i = 2; i <= 2 * n; i++) {
int sx, sy;
if (i <= 1 + n) {
sx = 1;
sy = i - 1;
} else {
sx = i - n;
sy = n;
}
long long k = 0;
for (int j = 0; sx + j <= n && sy - j > 0; j++) {
k += a[sx + j][sy - j];
}
d2[i] = k;
}
long long omax = 0, emax = 0;
long long ox, oy, ex, ey;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
long long k = d1[i - j] + d2[i + j] - a[i][j];
if (((i + j) & 1) && k >= omax) {
omax = k;
ox = i;
oy = j;
} else if (!((i + j) & 1) && k >= emax) {
emax = k;
ex = i;
ey = j;
}
}
}
cout << omax + emax << '\n';
cout << ex << " " << ey << " " << ox << " " << oy << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, s;
struct node {};
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> s;
long long t1 = 0;
t1 = k * (n - 1);
if (s > t1 || k > s) {
cout << "NO\n";
} else {
cout << "YES\n";
long long x, last;
long long cnt = 0;
last = 1;
while (s > 0) {
x = min(s - k + 1, n - 1);
if (cnt % 2 == 0) {
cout << last + x << ' ';
last = last + x;
cnt++;
} else {
cout << last - x << ' ';
last = last - x;
cnt++;
}
k--;
s -= x;
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct _cert {
template <typename T>
_cert& operator<<(T) {
return *this;
}
};
_cert _cer;
template <typename T>
void dprint(T begin, T end) {
for (auto i = begin; i != end; i++) {
_cer << (*i) << " ";
}
_cer << "\n";
}
int n;
long long a[600];
vector<int> vv;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
for (int i = 1; i < 40000; ++i) {
if (a[0] / i >= a[0] % i) vv.push_back(i);
}
for (int i = 1; i < 40000; ++i) {
long long k = a[0] / i;
if (k > 0 && (a[0] / k >= a[0] % k)) vv.push_back(k);
k -= 1;
if (k > 0 && (a[0] / k >= a[0] % k)) vv.push_back(k);
}
sort(vv.begin(), vv.end());
vv.resize(unique(vv.begin(), vv.end()) - vv.begin());
random_shuffle(a, a + n);
for (int i = vv.size() - 1; i >= 0; --i) {
int x = vv[i];
int fl = 0;
for (int j = 0; j < n; ++j) {
if (a[j] / x < a[j] % x) {
fl = 1;
break;
}
}
if (!fl) {
long long ans = 0;
for (int j = 0; j < n; ++j) {
ans += a[j] / (x + 1);
if (a[j] % (x + 1)) ++ans;
}
cout << ans << "\n";
return 0;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int inline read() {
int num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const int maxn = 100010;
int n, head[maxn], cnt, size[maxn], total, fa[maxn], p[maxn], dep[maxn],
f[maxn];
struct Edge {
int nxt, to;
} edge[maxn];
void add_edge(int x, int y) {
edge[++cnt].nxt = head[x];
edge[cnt].to = y;
head[x] = cnt;
}
void dfs(int x) {
dep[x] = dep[fa[x]] + 1;
size[x] = 1;
int flag = 1;
for (int i = head[x]; i; i = edge[i].nxt) {
int v = edge[i].to;
dfs(v);
flag = 0;
f[x] = max(f[v], f[x]);
size[x] += size[v];
}
if (flag) f[x] = dep[x];
}
struct Node {
int val, id;
} A[maxn];
int line[maxn], opt[maxn * 10], top, ID[maxn];
bool cmp(Node x, Node y) { return x.val < y.val; }
void solve(int x, int id) {
line[id] = x;
if (size[x] == 1) return;
int tot = 0;
for (int i = head[x]; i; i = edge[i].nxt) {
int v = edge[i].to;
A[++tot].val = f[v];
A[tot].id = v;
}
int sum = id + 1;
sort(A + 1, A + tot + 1, cmp);
for (int i = 1; i <= tot; i++) {
int v = A[i].id;
ID[v] = sum;
sum = ID[v] + size[v];
}
Node B[tot + 1];
for (int i = 1; i <= tot; i++) B[i] = A[i];
for (int i = 1; i <= tot; i++) {
int v = B[i].id;
solve(v, ID[v]);
}
}
void Getopt(int x) {
if (x == n + 1) return;
while (fa[line[x]] != p[line[x]]) {
p[line[x]] = fa[p[line[x]]];
opt[++top] = line[x];
}
Getopt(x + 1);
}
int main() {
n = read();
for (int i = 2; i <= n; i++) {
int v = read() + 1;
add_edge(v, i);
fa[i] = v;
}
dfs(1);
solve(1, 1);
for (int i = 2; i <= n; i++) p[line[i]] = line[i - 1];
Getopt(2);
for (int i = 1; i <= n; i++) printf("%d ", line[i] - 1);
printf("\n%d\n", top);
for (int i = 1; i <= top; i++) printf("%d ", opt[i] - 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int> > m;
int n;
void dfs(int v, int p) {
if (~p) printf(" ");
printf("%d", v + 1);
for (int(i) = 0; (i) < ((int)m[v].size()); ++(i))
if (m[v][i] != p) dfs(m[v][i], v);
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (n); ++(i)) {
int p, q;
scanf("%d%d", &p, &q);
--p;
--q;
m[p].push_back(q);
m[q].push_back(p);
}
for (map<int, vector<int> >::iterator it = m.begin(); it != m.end(); ++it)
if ((int)it->second.size() == 1) {
dfs(it->first, -1);
cout << endl;
exit(0);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int A[100001], B[3300033], D[3300033], O[100001], P[100001], Q, a[100001],
b[200002], c[200002], d[100001], e[3300033], f[100001], g[100001],
h[100001], l[3300033][2], m, n, r, s[3300033], t;
double C[3300033], E[3300033], F[3300033], x;
inline double _k(int u, int v) {
if (D[u] == D[v])
return C[v] - C[u] < 1e-10 ? max(E[u], E[v]) : x;
else
return max(E[u], E[v]) <= (C[v] - C[u]) / (D[u] - D[v]) + 1e-10 &&
(C[v] - C[u]) / (D[u] - D[v]) <= min(F[u], F[v]) + 1e-10
? (C[v] - C[u]) / (D[u] - D[v])
: x;
}
inline void _j(int u) { s[u] = s[l[u][0]] + s[l[u][1]] + 1; }
inline int _i(int u, int v) {
while (true)
if (v == s[l[u][0]] + 1)
return u;
else if (v <= s[l[u][0]])
u = l[u][0];
else
v -= s[l[u][0]] + 1, u = l[u][1];
}
inline void _h(int& u, int v) {
int w = l[u][v];
l[u][v] = l[w][v ^ 1], _j(l[w][v ^ 1] = u), u = w;
}
int _g(int& u, int v) {
if (u != v)
return s[u]--, C[u] + D[u] * F[v] < C[v] + D[v] * F[v]
? s[l[u][0]] + 1 + _g(l[u][1], v)
: _g(l[u][0], v);
else if (!l[u][0] || !l[u][1])
return l[u][1] ? u = l[u][1], 0 : s[u = l[u][0]];
else if (e[l[u][0]] < e[l[u][1]])
_h(u, 0), s[u] = s[l[u][0]] + s[l[u][1]], _g(l[u][0], v);
else
return _h(u, 1), s[u] = s[l[u][0]] + s[l[u][1]],
s[l[u][0]] + 1 + _g(l[u][1], v);
}
int _f(int& u, int v) {
int S;
if (!u)
e[u = v] = rand(), S = 1;
else if (C[v] + D[v] * E[v] < C[u] + D[u] * E[v])
S = _f(l[u][0], v), e[l[u][0]] < e[u] ? _h(u, 0), 0 : 0;
else
S = s[l[u][0]] + 1 + _f(l[u][1], v), e[l[u][1]] < e[u] ? _h(u, 1), 0 : 0;
return _j(u), S;
}
inline bool _e(int u, int v) { return F[u] < F[v]; }
inline bool _d(int u, int v) { return E[u] < E[v]; }
inline void _c(int u, int v, int w, double y) {
int i = u, j = v;
double z = d[u] + d[v];
while (h[i] != h[j]) d[h[i]] < d[h[j]] ? j = f[h[j]] : i = f[h[i]];
z -= d[i] < d[j] ? d[j = i] << 1 : d[i = j] << 1, z = z / w + y;
while (h[u] != h[i])
B[++t] = A[h[u]], C[A[h[u]] = t] = d[u] + w * y, D[t] = -w, E[t] = y,
F[t] = y += (double)(d[u] - d[f[h[u]]]) / w, u = f[h[u]];
while (h[v] != h[j])
B[++t] = A[h[v]], C[A[h[v]] = t] = d[v] - w * z, D[t] = w, F[t] = z,
E[t] = z -= (double)(d[v] - d[f[h[v]]]) / w, v = f[h[v]];
if (d[u] < d[v])
B[++t] = A[h[v]], C[A[h[v]] = t] = d[v] - w * z, D[t] = w, F[t] = z,
E[t] = z -= (double)(d[v] - d[j]) / w;
else
B[++t] = A[h[u]], C[A[h[u]] = t] = d[u] + w * y, D[t] = -w, E[t] = y,
F[t] = y += (double)(d[u] - d[i]) / w;
}
void _b(int u) {
if (s[u] = 0, g[u]) h[g[u]] = h[u], _b(g[u]);
for (int& i = a[u]; i; i = b[i])
if (c[i] != f[u] && c[i] != g[u]) _b(h[c[i]] = c[i]);
}
void _a(int u) {
s[u] = 1, d[u] = d[f[u]] + 1;
for (int i = a[u]; i; i = b[i])
if (c[i] != f[u])
f[c[i]] = u, _a(c[i]), s[u] += s[c[i]],
g[u] = s[g[u]] < s[c[i]] ? c[i] : g[u];
}
int main() {
scanf("%d%d", &n, &m), srand(time(0)), x = 1e9 + 7;
for (int i = 1, u, v; i < n; i++)
scanf("%d%d", &u, &v), b[++t] = a[u], c[a[u] = t] = v, b[++t] = a[v],
c[a[v] = t] = u;
_a(1), _b(h[1] = 1), t = 0;
for (int u, v, w, y; m; m--)
scanf("%d%d%d%d", &y, &w, &u, &v), _c(u, v, w, y);
for (int i = 1; i <= n; i++)
if (A[i]) {
for (Q = r = 0; A[i];) O[++Q] = A[i], P[Q] = A[i], A[i] = B[A[i]];
sort(O + 1, O + Q + 1, _d), sort(P + 1, P + Q + 1, _e);
for (int j = 1, k = 1, u, v = 0;;)
if (j <= Q && (Q < k || E[O[j]] - F[P[k]] < 1e-10) && E[O[j]] < x)
u = _f(r, O[j]), u != 1 ? x = min(x, _k(_i(r, u - 1), O[j])) : 0.0,
u != ++v ? x = min(x, _k(O[j], _i(r, u + 1))) : 0.0, j++;
else if (k <= Q && (Q < j || 1e-10 < E[O[j]] - F[P[k]]) && F[P[k]] < x)
u = _g(r, P[k]),
u != --v&& u ? x = min(x, _k(_i(r, u), _i(r, u + 1))) : 0.0, k++;
else
break;
}
return 0 & (1e9 < x ? puts("-1") : printf("%.30lf\n", x));
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
string s;
cin>>n>>s;
int ans=1;
for(int i=0;i<n-1;i++){
if(s[i]!=s[i+1]){
ans++;
}
}
cout<<ans<<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define sz(a) (int)(a.size())
#define all(a) a.begin(),a.end()
#define lb lower_bound
#define ub upper_bound
#define owo ios_base::sync_with_stdio(0);cin.tie(0);
#define MOD (ll)(998244353)
#define INF (ll)(1e18)
#define debug(...) fprintf(stderr, __VA_ARGS__),fflush(stderr)
#define time__(d) for(long blockTime = 0; (blockTime == 0 ? (blockTime=clock()) != 0 : false);\
debug("%s time : %.4fs\n", d, (double)(clock() - blockTime) / CLOCKS_PER_SEC))
typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> PII;
typedef pair<int,int> pii;
typedef vector<vector<int>> vii;
typedef vector<vector<ll>> VII;
const int MAXN = 1e6+5;
int id[MAXN];
int par[MAXN];
int ans[MAXN];
vii comp(MAXN);
vector<vector<pii>> adj(MAXN);
int find(int x){
if(x==par[x])return x;
return par[x] = find(par[x]);
}
bool unite(int a,int b){
a = find(a);
b = find(b);
if(a==b)return 0;
if(sz(comp[a]) > sz(comp[b]))swap(a,b);
for(int x:comp[a])comp[b].pb(x);
par[a] = b;
comp[a].clear();
return 1;
}
void dfs(int v,int u,int mx){
ans[v] = mx;
for(pii x:adj[v]){
if(x.fi == u)continue;
dfs(x.fi,v,max(mx,x.se));
}
}
int main()
{
owo
int n,q,s,d;
cin>>n>>q>>s>>d;
vector<int>a(n);
set<int>rock,cur;
for(int i=0;i<n;i++){
cin>>a[i];
cur.insert(i);
comp[i].pb(i);
rock.insert(a[i]);
par[i] = i;
id[a[i]] = i;
}
int cnt = n;
while(cnt>1){
vector<pair<pii,int>>add;
for(int s:cur){
pii e = {-1,-1};
int mn = 1e9;
for(int x:comp[s])rock.erase(a[x]);
for(int x:comp[s]){
auto it = rock.lb(a[x]-d);
if(it != rock.end()){
if(mn > *it - (a[x]-d)){
mn = *it - (a[x]-d);
e = {id[*it],x};
}
}
if(it != rock.begin()){
it--;
if(mn > (a[x]-d) - *it){
mn = a[x]-d - *it;
e = {id[*it],x};
}
it++;
}
it = rock.lb(a[x]+d);
if(it != rock.end()){
if(mn > *it - (a[x]+d)){
mn = *it - (a[x]+d);
e = {id[*it],x};
}
}
if(it != rock.begin()){
it--;
if(mn > (a[x]+d) - *it){
mn = a[x]+d - *it;
e = {id[*it],x};
}
}
}
for(int x:comp[s])rock.insert(a[x]);
if(e.fi != -1)add.pb({e,mn});
}
for(auto x:add){
int a = x.fi.fi;
int b = x.fi.se;
if(find(a) != find(b)){
adj[a].pb({b,x.se});
adj[b].pb({a,x.se});
cnt--;
a = find(a);
b = find(b);
cur.erase(a);
cur.erase(b);
unite(a,b);
cur.insert(find(a));
}
}
}
s--;
dfs(s,-1,0);
while(q--){
int i,k;
cin>>i>>k;
i--;
if(ans[i] <= k)cout<<"YES"<<'\n';
else cout<<"NO"<<'\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1234567;
int n, m;
int a[N];
int l[N], r[N], ans[N];
vector<int> v[N];
int mas[N];
map<int, int> M;
void update(int x, int y) {
for (int i = x; i <= n; i = i * 2 - (i & (i - 1))) mas[i] = min(mas[i], y);
}
int datvla(int x) {
int pas = n + 100;
for (int i = x; i > 0; i = (i & (i - 1))) pas = min(pas, mas[i]);
return pas;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
cin >> l[i] >> r[i];
v[l[i]].push_back(i);
}
for (int i = 1; i <= n; i++) mas[i] = n + 100;
for (int i = n; i >= 1; i--) {
int t = M[a[i]];
if (t != 0) {
update(t, t - i);
}
M[a[i]] = i;
for (int j : v[i]) {
ans[j] = datvla(r[j]);
if (ans[j] > n) ans[j] = -1;
}
}
for (int i = 1; i <= m; i++) cout << ans[i] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
int randint1() {
return ((long long)rand() * 89543534534LL + rand()) % 170215161;
}
int randint2() {
return ((long long)rand() * 89543534534LL + rand()) % 151728211;
}
map<pair<int, int>, long long> mp;
int sum1[500005], sum2[500005], val1[500005], val2[500005];
long long c[500005];
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
mp.clear();
for (int i = 1; i <= n; i++) {
scanf("%lld", &c[i]);
val1[i] = randint1();
val2[i] = randint2();
sum1[i] = sum2[i] = 0;
}
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
sum1[v] = (sum1[v] + val1[u]) % 170215161;
sum2[v] = (sum2[v] + val2[u]) % 151728211;
}
long long g = 0;
for (int i = 1; i <= n; i++)
if (sum1[i] && sum2[i]) mp[make_pair(sum1[i], sum2[i])] += c[i];
for (auto it : mp) g = gcd(g, it.second);
printf("%lld\n", g);
}
return 0;
}
| 5 |
#include<iostream>
#include<vector>
using namespace std;
typedef long long ll;
int main(){
int s, t, d;
cin >> s >> t >> d;
vector<ll> v(d);
for(int i = 0; i < d; i++) cin >> v[i], v[i] *= -1;
ll target = s-t;
ll sum = 0, ma = 0;
for(int i = 0; i < d; i++){
sum += v[i];
if(sum >= target){
cout << i+1 << endl;
return 0;
}
ma = max(ma, sum);
}
if(sum <= 0){
cout << -1 << endl;
return 0;
}
ll ans = (target-ma+sum-1)/sum*d;
target -= (target-ma+sum-1)/sum*sum;
for(int i = 0; i <= d; i++){
if(target <= 0){
cout << ans+i << endl;
return 0;
}
if(i < d) target -= v[i];
}
}
| 0 |
#include <iostream>;
using namespace std;
int main()
{
int A, B, C;
cin >> A >> B >> C;
printf("%s\n", A == B && B == C ? "Yes" : "No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, u;
cin >> n >> u;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int k = 0;
double ans = -1;
for (int i = 0; i < n; i++) {
while (k < n - 1 && a[k + 1] - a[i] <= u) k++;
if (k - i > 1) {
ans = max(ans, (a[k] - a[i + 1]) * 1.0 / (a[k] - a[i]));
}
}
if (ans < 0)
cout << -1 << endl;
else
cout << fixed << setprecision(9) << ans << endl;
}
| 2 |
#include <iostream>
using namespace std;
int main(void)
{
int n;
while(cin >> n,n){
int max_no=-1,max_val=-1;
int no,a,b;
while(--n, n >= 0){
cin >> no >> a >> b;
if(max_val < a+b){
max_no = no;
max_val = a+b;
}
}
cout << max_no << ' ' << max_val << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, t;
vector<int> one, two, thr;
int main() {
int i;
while (~scanf("%d", &n)) {
one.clear();
two.clear();
thr.clear();
for (i = 1; i <= n; i++) {
scanf("%d", &t);
if (t == 1)
one.push_back(i);
else if (t == 2)
two.push_back(i);
else if (t == 3)
thr.push_back(i);
}
ans = one.size() < two.size() ? one.size() : two.size();
if (ans > thr.size()) ans = thr.size();
printf("%d\n", ans);
for (i = 0; i < ans; i++) {
printf("%d %d %d\n", one[i], two[i], thr[i]);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, dst, ans = 0;
cin >> x;
for (int i = 5; i > 0 || x != 0; i--) {
if (x % i == 0) {
ans = ans + (x / i);
x = x % i;
} else if ((x % i) && (x / i) != 0) {
ans = ans + (x / i);
x = x % i;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int len = 55;
int arr[len][len], n, m;
pair<int, int> pos[len], tar[len];
vector<pair<pair<int, int>, pair<int, int> > > out;
void print() {
for (int i = 1; i <= n; i++) printf("-");
printf("\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) printf("%d", arr[i][j]);
printf("\n");
}
}
void mov(int x1, int y1, int x2, int y2) {
while (x1 != x2) {
if (x2 < x1) {
out.push_back(make_pair(make_pair(x1, y1), make_pair(x1 - 1, y1)));
arr[x1 - 1][y1] = arr[x1][y1];
arr[x1][y1] = 0;
x1--;
} else {
out.push_back(make_pair(make_pair(x1, y1), make_pair(x1 + 1, y1)));
arr[x1 + 1][y1] = arr[x1][y1];
arr[x1][y1] = 0;
x1++;
}
}
while (y1 != y2) {
if (y2 < y1) {
out.push_back(make_pair(make_pair(x1, y1), make_pair(x1, y1 - 1)));
arr[x1][y1 - 1] = arr[x1][y1];
arr[x1][y1] = 0;
y1--;
} else if (y2 > y1) {
out.push_back(make_pair(make_pair(x1, y1), make_pair(x1, y1 + 1)));
arr[x1][y1 + 1] = arr[x1][y1];
arr[x1][y1] = 0;
y1++;
}
}
pos[arr[x1][y1]] = make_pair(x1, y1);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &pos[i].first, &pos[i].second);
arr[pos[i].first][pos[i].second] = i;
}
for (int i = 1; i <= m; i++) scanf("%d %d", &tar[i].first, &tar[i].second);
if (n == 1) {
printf("0\n");
return 0;
}
int po = 1;
for (int i = 1; i <= n; i++) {
int cur = 1;
for (int j = 1; j <= n; j++)
if (arr[i][j]) mov(i, j, i, cur++);
for (int j = n; j >= 1; j--)
if (arr[i][j]) mov(i, j, i, j + po - 1);
for (int j = 1; j <= n; j++)
if (arr[i][j]) mov(i, j, 1, j), po++;
}
for (int i = n; i >= 3; i--) {
for (int j = 1; j <= n; j++)
if (arr[1][j] && tar[arr[1][j]].first == i) {
pair<int, int> cur = tar[arr[1][j]];
mov(1, j, 2, j);
mov(2, j, 2, cur.second);
mov(2, cur.second, cur.first, cur.second);
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j < n; j++) {
if (arr[1][j] == 0 && arr[1][j + 1] == 0)
continue;
else if (arr[1][j] == 0)
mov(1, j + 1, 1, j);
else if (arr[1][j + 1] == 0)
mov(1, j, 1, j + 1);
else if (tar[arr[1][j]].second > tar[arr[1][j + 1]].second) {
mov(1, j, 2, j);
mov(2, j, 2, j + 1);
mov(1, j + 1, 1, j);
mov(2, j + 1, 1, j + 1);
}
}
for (int j = 1; j <= n; j++)
if (arr[1][j] && tar[arr[1][j]].first == 2) mov(1, j, 2, j);
for (int i = 1; i <= 2; i++) {
int cur = 1;
for (int j = 1; j <= n; j++)
if (arr[i][j]) mov(i, j, i, cur++);
for (int j = n; j >= 1; j--)
if (arr[i][j]) mov(i, j, tar[arr[i][j]].first, tar[arr[i][j]].second);
}
printf("%d\n", out.size());
for (int i = 0; i < out.size(); i++)
printf("%d %d %d %d\n", out[i].first.first, out[i].first.second,
out[i].second.first, out[i].second.second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[500], c, i, n, big;
int main() {
while (~scanf(" %d %d", &n, &c)) {
for (i = 0; i < n; i++) {
scanf(" %d", &a[i]);
}
big = 0;
for (i = 0; i < n - 1; i++) {
if (a[i] - a[i + 1] - c > big) big = a[i] - a[i + 1] - c;
}
printf("%d\n", big);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
while (cin >> n >> m) {
int nx = n, ny = m, temp;
vector<int> x, y;
for (int i = 0; i < n; i++) {
cin >> temp;
x.push_back(temp);
}
for (int i = 0; i < m; i++) {
cin >> temp;
y.push_back(temp);
}
int vx = x[0], vy = y[0], py(0), px(0), files(0);
while (px != nx and py != ny) {
if (vx == vy) {
files++;
px++;
py++;
if (px == nx or py == ny) break;
vx = x[px];
vy = y[py];
} else if (vx > vy) {
vy += y[++py];
} else {
vx += x[++px];
}
}
cout << files << endl;
}
}
| 2 |
#include <bits/stdc++.h>
void check(std::vector<int>& v1, std::vector<int>& v2, std::vector<int>& v3,
char* b, char newC) {
if (v1.size() == 0) {
if (v2.size() > 1) {
b[v2.back()] = newC;
v1.push_back(v2.back());
v2.pop_back();
} else {
b[v3.back()] = newC;
v1.push_back(v3.back());
v3.pop_back();
}
}
}
int main() {
int nt;
scanf("%d", &nt);
for (int i = 0; i < nt; i++) {
char b[100 + 1];
scanf("%100s", b);
std::vector<int> lc;
std::vector<int> uc;
std::vector<int> di;
for (int i = 0; b[i] != 0; i++) {
if ('a' <= b[i] && b[i] <= 'z') {
lc.push_back(i);
} else if ('A' <= b[i] && b[i] <= 'Z') {
uc.push_back(i);
} else {
di.push_back(i);
}
}
check(lc, uc, di, b, 'a');
check(uc, lc, di, b, 'A');
check(di, lc, uc, b, '0');
printf("%s\n", b);
}
}
| 1 |
#include <iostream>
using namespace std;
int main(){
double x,high=0,low=1000000;
while(cin>>x){
if(x>high)high=x;
if(x<low) low=x;
}
cout<<high-low<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << "\t";
return *this;
}
} dbg;
template <class A, class B>
ostream& operator<<(ostream& o, const pair<A, B>& p) {
return o << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "[";
for (__typeof((v).end()) it = (v).begin(); it != (v).end(); ++it)
o << *it << ", ";
return o << "]";
}
template <class T>
ostream& operator<<(ostream& o, const set<T>& v) {
o << "[";
for (__typeof((v).end()) it = (v).begin(); it != (v).end(); ++it)
o << *it << ", ";
return o << "]";
}
template <class T>
inline void MAX(T& a, T b) {
if (a < b) a = b;
}
template <class T>
inline void MIN(T& a, T b) {
if (a > b) a = b;
}
template <class T>
inline bool read(T& x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int main() {
long long N, x, y;
while (cin >> N >> x >> y) {
for (__typeof(N) i = (1); i <= N; ++i) {
long long k = ({
long long a;
scanf("%lld", &a);
a;
});
long long a = (k * x) / (x + y);
long long b = (k * y) / (x + y);
if (a + b == k) {
puts("Both");
continue;
}
k -= (a + b);
double p = (a + 1) / double(x);
double q = (b + 1) / double(y);
if (p < q)
puts("Vanya");
else if (p > q)
puts("Vova");
else
puts("Both");
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using lld = long double;
using ulli = unsigned long long int;
using pll = pair<lli, lli>;
using ttt = pair<lli, pll>;
using vttt = vector<ttt>;
using vll = vector<pll>;
using vl = vector<lli>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using cd = complex<lld>;
const double PI = acos(-1);
inline lli mpow(lli a, lli b, lli m = 1000000007) {
lli ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
a = (a * a) % m;
b /= 2;
}
return ans;
}
int n, m, arr[100010];
lli h1[100010], h2[100010];
lli ohash1[100010], thash1[100010], ohash2[100010], thash2[100010];
vvi adj(100010);
void calc(lli hash1[], lli hash2[], vvi& adj) {
for (int i = 1; i < n + 1; i++) {
hash1[i] = 0;
hash2[i] = 0;
for (auto& x : adj[i]) {
hash1[i] += h1[x];
hash2[i] += h2[x];
if (hash1[i] >= 1000000007) hash1[i] -= 1000000007;
if (hash2[i] >= 1000000007) hash2[i] -= 1000000007;
}
}
}
bool check(int off) {
for (int i = 1; i < n + 1; i++) arr[i] = (i + off - 1) % n + 1;
vvi tadj(n + 2);
for (int i = 1; i < n + 1; i++) tadj[arr[i]] = adj[i];
for (int i = 1; i < n + 1; i++) {
for (auto& x : tadj[i]) x = arr[x];
}
calc(thash1, thash2, tadj);
for (int i = 1; i < n + 1; i++) {
if (thash1[i] != ohash1[i]) return 0;
if (thash2[i] != ohash2[i]) return 0;
}
return 1;
}
int tejas_919(int kkkk) {
for (int i = 0; i < 100010; i++) h1[i] = (mpow(167, i) * i) % 1000000007;
for (int i = 0; i < 100010; i++) h2[i] = mpow(367, i);
lli k, q, u, v, temp = 0, ans = 0;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
calc(ohash1, ohash2, adj);
for (int i = 1; i < n; i++) {
if (n % i == 0 && check(i)) return cout << "Yes" << '\n', 0;
}
cout << "No" << '\n';
return 0;
}
signed main() {
if (!0) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
cout << fixed << setprecision(10);
int t = 1;
for (int i = 0; i < t; i++) {
tejas_919(i + 1);
}
{};
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int modPow(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int arr[5005], dp[5005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) dp[i] = dp[i - 1] + arr[i];
double ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
if (j - i + 1 < k)
continue;
else {
double val = double(dp[j] - dp[i - 1]) / (j - i + 1);
ans = max(ans, val);
}
}
}
cout << setprecision(10) << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B, class C>
void dfs(int x, A& e, B& vis, C& rez) {
rez += x;
vis[x] = 1;
for (int y : e[x])
if (!vis[y]) dfs(y, e, vis, rez);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
vector<tuple<int, int, int>> tri;
map<array<int, 3>, int> idx;
cin >> n;
set<pair<int, int>> ee;
auto xr = [&](int x, int y) {
if (x > y) swap(x, y);
if (ee.count({x, y}))
ee.erase({x, y});
else
ee.insert({x, y});
};
for (int i = 0; i < n - 2; i++) {
int a, b, c;
cin >> a >> b >> c;
tri.emplace_back(a, b, c);
xr(a, b);
xr(b, c);
xr(c, a);
array<int, 3> w = {a, b, c};
sort(w.begin(), w.end());
idx[w] = i + 1;
}
set<pair<int, int>> pq;
vector<set<int>> adj(n + 1);
vector<basic_string<int>> e(n + 1);
for (auto [a, b, c] : tri) {
adj[a].insert(b);
adj[a].insert(c);
adj[b].insert(c);
adj[b].insert(a);
adj[c].insert(a);
adj[c].insert(b);
}
for (int i = 1; i <= n; i++) pq.insert({adj[i].size(), i});
for (auto [x, y] : ee) e[x] += y, e[y] += x;
string vis(n + 1, 0);
basic_string<int> rez, sol;
dfs(1, e, vis, rez);
for (int x : rez) cout << x << ' ';
cout << '\n';
auto decr = [&](int a, int b) {
auto it = pq.find({adj[b].size(), b});
if (it == pq.end()) return;
pq.erase(it);
adj[b].erase(a);
if (adj[b].size()) pq.insert({adj[b].size(), b});
};
while (pq.size()) {
auto it = pq.begin();
auto [x, y] = *it;
if (x < 2) break;
pq.erase(it);
int a = y;
int b = *adj[y].begin();
int c = *next(adj[y].begin());
array<int, 3> w = {a, b, c};
sort(w.begin(), w.end());
sol.push_back(idx[w]);
decr(a, b);
decr(a, c);
}
for (int x : sol) cout << x << ' ';
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], k, b[200005], cc[200005];
int main() {
cin >> n >> k;
char c;
for (int i = 1; i <= n; i++) {
cin >> c;
a[i] = c - 48;
}
int f = 0, mi = n + 1;
for (int i = 1; i <= k; i++) {
int p = a[i];
cc[i] = p;
for (int j = i + k; j <= n; j = j + k) {
if (p < a[j] && j < mi) {
f = 1;
mi = j;
break;
} else if (p > a[j]) {
if (j < mi) f = 0;
mi = min(mi, j);
break;
}
}
}
cout << n << endl;
if (f == 0) {
for (int i = 1; i <= n; i++) {
if (i % k != 0)
cout << cc[i % k];
else
cout << cc[k];
}
} else {
for (int i = k; i >= 1; i--) {
if (a[i] != 9) {
cc[i] = a[i] + 1;
for (int j = i + 1; j <= k; j++) {
cc[j] = 0;
}
break;
}
}
for (int i = 1; i <= n; i++) {
if (i % k != 0)
cout << cc[i % k];
else
cout << cc[k];
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class SegTree {
public:
SegTree(int _n) : n(_n) {
x = vector<int>(_n * 4);
y = vector<int>(_n * 4);
}
void PushDown(int t, int l, int r) {
if (l == r) return;
if (y[t] == 0) return;
x[t + t] += y[t];
y[t + t] += y[t];
x[t + t + 1] += y[t];
y[t + t + 1] += y[t];
y[t] = 0;
}
void Insert(int t, int a, int l, int r, int p, int q) {
PushDown(t, l, r);
if (p <= l && r <= q) {
x[t] += a;
y[t] += a;
return;
}
int mid = (l + r) >> 1;
if (p <= mid) Insert(t + t, a, l, mid, p, q);
if (mid + 1 <= q) Insert(t + t + 1, a, mid + 1, r, p, q);
x[t] = max(x[t + t], x[t + t + 1]);
}
int Query(int t, int l, int r, int p, int q) {
PushDown(t, l, r);
if (p <= l && r <= q) return x[t];
int mid = (l + r) >> 1;
int ans = 0;
if (p <= mid) ans = max(ans, Query(t + t, l, mid, p, q));
if (mid + 1 <= q) ans = max(ans, Query(t + t + 1, mid + 1, r, p, q));
return ans;
}
int n;
vector<int> x, y;
};
int Find(deque<pair<int, int>>& q, int v) {
if (q.back().first < v) return q.back().second;
int L = 0, R = q.size() - 1;
while (L + 1 < R) {
int mid = (L + R) >> 1;
if (q[mid].first < v)
L = mid;
else
R = mid;
}
return q[L].second;
}
const int MAXN = 200010;
vector<pair<int, int>> rp[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> ox(n);
for (int i = 0; i < n; ++i) cin >> ox[i];
vector<int> x{0};
for (int i = 0; i < n; ++i) {
if (ox[i] != 1) continue;
for (int j = i + 1; j < n; ++j) x.push_back(ox[j]);
for (int j = 0; j <= i; ++j) x.push_back(ox[j]);
break;
}
deque<pair<int, int>> fq, bq;
for (int i = 1; i <= n; ++i) {
while (!fq.empty() && fq.back().first > x[i]) {
fq.pop_back();
}
fq.push_back({x[i], i});
}
for (int i = n; i >= 1; --i) {
while (!bq.empty() && bq.back().first > x[i]) {
rp[i].push_back(bq.back());
bq.pop_back();
}
reverse(rp[i].begin(), rp[i].end());
bq.push_back({x[i], i});
}
SegTree tree(n + n);
vector<int> p(n + 1);
for (int i = 1; i <= n; ++i) {
p[x[i]] = i;
}
set<int> s;
s.insert(0);
s.insert(n + 1);
for (int i = 1; i <= n; ++i) {
auto ib = s.lower_bound(p[i]);
auto ia = ib;
--ia;
tree.Insert(1, 1, 1, n + n, *ia + 1, *ib - 1);
s.insert(p[i]);
}
int ans = tree.Query(1, 1, n + n, 1, n), ansp = x[1];
for (int i = 1; i < n; ++i) {
int p = Find(bq, x[i]);
tree.Insert(1, -1, 1, n + n, i + 1, p - 1);
if (bq.back().second == i) bq.pop_back();
for (auto j : rp[i]) bq.push_back(j);
while (!fq.empty() && fq.back().first > x[i]) {
fq.pop_back();
}
fq.push_back({x[i], n + i});
int q = Find(fq, x[i]);
int dep = tree.Query(1, 1, n + n, q, q);
tree.Insert(1, 1, 1, n + n, q + 1, n + i - 1);
tree.Insert(1, dep + 1, 1, n + n, n + i, n + i);
int temp = tree.Query(1, 1, n + n, i + 1, n + i);
if (temp < ans) {
ans = temp;
ansp = x[i + 1];
}
}
cout << ans << " ";
for (int i = 0; i < n; ++i) {
if (ox[i] == ansp) {
cout << i << endl;
break;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 2e5 + 10, K = 22;
void Init();
long long Calc(int dg);
int BuildVirt(int dg);
void dfs1(int u, int ff);
int lca(int u, int v);
long long dfs2(int u, int dg);
long long dfs3(int u, long long cur, long long Sum);
struct Edge {
int to, dis, nx;
} edg[N * 3];
vector<int> keyp[N], g[N], fact[N];
int a[N], n, ky[N], kn, sk[N], skn, g2[N], pn, prime[N], sz[N], dfn[N],
dfs_clock = 0, dep[N], jp[N][K], edgn = 0;
int val[N];
bool vis[N];
long long prod[N], inv[N], phi[N], pr[N], s[N];
bool cmpdfn(int u, int v) { return dfn[u] < dfn[v]; }
void AddEdg(int ff, int u) {
edg[edgn] = (Edge){u, dep[u] - dep[ff], g2[ff]};
g2[ff] = edgn++;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
Init();
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1, -1);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
long long f = Calc(i), g = prod[i];
ans = (ans + f * g) % MOD;
}
ans = ans * inv[n] % MOD * inv[n - 1] % MOD;
cout << ans << endl;
return 0;
}
void Init() {
inv[0] = inv[1] = 1;
for (int i = 2; i <= n; ++i) inv[i] = (MOD - inv[MOD % i]) * (MOD / i) % MOD;
for (int i = 0; i <= n; ++i)
for (int j = 0; j < K; ++j) jp[i][j] = -1;
phi[1] = prod[1] = 1;
for (int i = 1; i <= n; ++i) pr[i] = i;
pn = 0;
for (int i = 2; i <= n; ++i) {
if (pr[i] == i) prime[pn++] = i;
for (int j = 0; j < pn && prime[j] <= pr[i] && i <= n / prime[j]; ++j)
pr[i * prime[j]] = prime[j];
int pre = i / pr[i];
if (pr[i] != pr[pre])
prod[i] = prod[pre] * inv[pr[i] - 1] % MOD,
phi[i] = phi[pre] * (pr[i] - 1);
else
prod[i] = 0, phi[i] = phi[pre] * pr[i];
}
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; j += i) fact[j].push_back(i);
for (int i = 1; i <= n; ++i)
for (int ai = a[i], j = 0; j < fact[ai].size(); ++j)
keyp[fact[ai][j]].push_back(i);
}
long long Calc(int dg) {
int rt = BuildVirt(dg);
long long initres = dfs2(rt, dg);
return dfs3(rt, initres, s[rt]);
}
int BuildVirt(int dg) {
for (int i = 0; i < (kn = keyp[dg].size()); ++i)
vis[ky[i] = keyp[dg][i]] = true;
sort(ky, ky + kn, cmpdfn);
for (int i = 0, m = kn, c; i + 1 < m; ++i)
if (!vis[c = lca(ky[i], ky[i + 1])]) vis[ky[kn++] = c] = true;
sort(ky, ky + kn, cmpdfn);
edgn = 0;
for (int i = 0; i < kn; ++i) g2[ky[i]] = -1;
skn = 0;
sk[skn++] = ky[0];
for (int i = 1; i < kn; sk[skn++] = ky[i++]) {
while (dfn[sk[skn - 1]] + sz[sk[skn - 1]] <= dfn[ky[i]]) --skn;
AddEdg(sk[skn - 1], ky[i]);
}
for (int i = 0; i < kn; ++i) vis[ky[i]] = false;
return ky[0];
}
void dfs1(int u, int ff) {
sz[u] = 1;
dfn[u] = ++dfs_clock;
jp[u][0] = ff;
if (ff != -1) {
for (int k = 0; jp[jp[u][k]][k] != -1; ++k) jp[u][k + 1] = jp[jp[u][k]][k];
dep[u] = dep[ff] + 1;
} else
dep[u] = 0;
for (int i = 0, v; i < g[u].size(); ++i)
if ((v = g[u][i]) != ff) {
dfs1(v, u);
sz[u] += sz[v];
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int step = dep[u] - dep[v], i = 0; step; step >>= 1, ++i)
if (step & 1) u = jp[u][i];
if (u == v) return u;
for (int k = 20; ~k; --k)
if (jp[u][k] != jp[v][k]) u = jp[u][k], v = jp[v][k];
return jp[u][0];
}
long long dfs2(int u, int dg) {
if (a[u] % dg == 0)
val[u] = phi[a[u]];
else
val[u] = 0;
s[u] = val[u];
long long sum = 0;
for (int i = g2[u]; ~i; i = edg[i].nx) {
Edge e = edg[i];
sum += (dfs2(e.to, dg) + s[e.to] * e.dis) % MOD;
s[u] = (s[u] + s[e.to]) % MOD;
}
return sum;
}
long long dfs3(int u, long long cur, long long Sum) {
long long res = cur * val[u] % MOD;
for (int i = g2[u]; ~i; i = edg[i].nx) {
Edge e = edg[i];
long long nx =
(cur + e.dis * ((Sum - s[e.to] + MOD - s[e.to]) % MOD)) % MOD;
res = (res + dfs3(e.to, nx, Sum)) % MOD;
}
return res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a;
int b[10], l[10], pp[10], sb;
bool sweet[10];
double tans, ans;
void Dfs(int pos, int chosen, int bSum, double p) {
if (pos == n) {
if (chosen > n / 2)
tans += p;
else {
double tp = a;
tp /= (sb - bSum + a);
tans += p * tp;
}
return;
}
double np = (double)pp[pos] / 100;
Dfs(pos + 1, chosen + 1, bSum + b[pos], p * np);
Dfs(pos + 1, chosen, bSum, p * (1 - np));
}
void GiveSweet(int pos, int left) {
if (pos == n) {
tans = 0;
Dfs(0, 0, 0, 1);
ans = max(ans, tans);
return;
}
pp[pos] = l[pos];
GiveSweet(pos + 1, left);
while (left && pp[pos] < 100) {
pp[pos] += 10;
GiveSweet(pos + 1, left - 1);
left--;
}
}
void GetAns() {
ans = 0;
GiveSweet(0, k);
printf("%.12f\n", ans);
}
int main() {
while (cin >> n >> k >> a) {
sb = 0;
for (int i = 0, _n(n); i < _n; ++i)
scanf("%d%d", b + i, l + i), sb += b[i], pp[i] = l[i];
GetAns();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m;
char ch[20][120];
int l[20], r[20], visit[20], dp[20][2];
int main() {
while (~scanf("%d%d", &n, &m)) {
memset(visit, 0, sizeof visit);
memset(r, 0, sizeof r);
memset(l, 0, sizeof l);
for (int i = n; i >= 1; i--) {
scanf("%s", ch[i] + 1);
for (int j = 2; j <= m + 1; j++)
if (ch[i][j] == '1') {
l[i] = j;
visit[i] = 1;
break;
}
for (int j = m + 1; j >= 2; j--)
if (ch[i][j] == '1') {
r[i] = j;
break;
}
}
int x = n;
while (!visit[x--] && x >= 1) n--;
if (n == 1) {
printf("%d\n", r[1] ? r[1] - 1 : 0);
continue;
}
memset(dp, INF, sizeof dp);
dp[1][0] = r[1] ? (r[1] - 1) * 2 : 0, dp[1][1] = m + 1;
for (int i = 2; i < n; i++) {
if (!visit[i]) {
dp[i][0] = dp[i - 1][0] + 1;
dp[i][1] = dp[i - 1][1] + 1;
continue;
}
dp[i][0] = min(dp[i - 1][0] + 2 * (r[i] - 1) + 1, dp[i][0]);
dp[i][0] = min(dp[i - 1][1] + m + 1 + 1, dp[i][0]);
dp[i][1] = min(dp[i - 1][1] + 2 * (m + 2 - l[i]) + 1, dp[i][1]);
dp[i][1] = min(dp[i - 1][0] + m + 1 + 1, dp[i][1]);
}
int ans = min(dp[n - 1][0] + r[n], dp[n - 1][1] + 1 + m + 2 - l[n]);
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t[100010][26];
bool win[100010], lose[100010];
int nxt;
void insert(const string& s) {
int v = 0;
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); ++it) {
int d = *it - 'a';
if (t[v][d] == -1) {
t[v][d] = nxt++;
}
v = t[v][d];
}
}
void solve(int root) {
bool is_leaf = true;
bool can_win = false, can_lose = false;
for (int i = 0; i < (26); ++i)
if (t[root][i] != -1) {
is_leaf = false;
solve(t[root][i]);
if (!win[t[root][i]]) can_win = true;
if (!lose[t[root][i]]) can_lose = true;
}
if (is_leaf) {
win[root] = false;
lose[root] = true;
} else {
win[root] = can_win;
lose[root] = can_lose;
}
}
int main() {
ios::sync_with_stdio(false);
;
int n, k;
cin >> n >> k;
memset(t, -1, sizeof(t));
nxt = 1;
while (n--) {
string s;
cin >> s;
insert(s);
}
solve(0);
if (!win[0])
cout << "Second\n";
else {
if (lose[0]) {
cout << "First\n";
} else {
if (k & 1)
cout << "First\n";
else
cout << "Second\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using db = long double;
using pll = pair<long long, long long>;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t, i, x, j, y, z, k, n;
cin >> n;
long long n1 = n / 2, n2 = n - (n / 2);
std::vector<pll> v;
for (i = 1; i < n1 + 1; i += 1) {
for (j = n1 + 1; j < n + 1; j += 1) {
v.push_back(make_pair(i, j));
}
}
cout << v.size() << '\n';
for (auto zx : v) cout << zx.first << " " << zx.second << '\n';
;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5 + 1;
long long p[19], dp[36][19][19], n;
char ans[36][19][19];
string s;
long long solve(long long idx, long long a, long long b) {
if (a == 0 && b == 0) return 0;
if (dp[idx][a][b] != -1) return dp[idx][a][b];
if (a == 0) {
ans[idx][a][b] = 'H';
return dp[idx][a][b] = (s[idx] - 48) * p[n - b] + solve(idx - 1, a, b - 1);
}
if (b == 0) {
ans[idx][a][b] = 'M';
return dp[idx][a][b] = (s[idx] - 48) * p[n - a] + solve(idx - 1, a - 1, b);
}
long long h = solve(idx - 1, a, b - 1);
long long m = solve(idx - 1, a - 1, b);
if ((s[idx] - 48) * p[n - b] + h > (s[idx] - 48) * p[n - a] + m) {
ans[idx][a][b] = 'H';
return dp[idx][a][b] = (s[idx] - 48) * p[n - b] + h;
}
ans[idx][a][b] = 'M';
return dp[idx][a][b] = (s[idx] - 48) * p[n - a] + m;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
cin >> n;
cin >> s;
long long i;
p[0] = 1;
memset(dp, -1, sizeof(dp));
for (i = 1; i < 19; i++) p[i] = p[i - 1] * 10;
long long h = solve(2 * n - 1, n, n);
string temp;
long long a = n, b = n, idx = 2 * n - 1;
while (idx >= 0) {
temp = ans[idx][a][b] + temp;
if (ans[idx][a][b] == 'H')
b--;
else
a--;
idx--;
}
cout << temp;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct trp {
int x, y, z;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m, x, y;
cin >> n >> m >> x >> y;
char s[n][m];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
cin >> s[i][j];
}
}
long long int ans = 0;
if (2 * x <= y) {
y = 2 * x;
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (s[i][j] == '.' && s[i][j + 1] == '.' && j != m - 1) {
ans += y;
j++;
} else if (s[i][j] == '.')
ans += x;
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_CLOUDS = 100 * 1000;
struct Cloud {
int start, speed;
};
int nbClouds;
long long cloudSize, maxSpeed;
Cloud clouds[MAX_CLOUDS];
int main() {
scanf("%d%lld%lld", &nbClouds, &cloudSize, &maxSpeed);
vector<long long> left;
vector<long long> right;
for (int iCloud = 0; iCloud < nbClouds; iCloud++) {
int start, speed;
scanf("%d%d", &start, &speed);
if (speed == 1) {
left.push_back(start);
} else {
right.push_back(start + cloudSize);
}
}
sort(left.begin(), left.end());
sort(right.begin(), right.end());
long long total = 0;
int iRight = right.size();
for (int iLeft = (int)left.size() - 1; iLeft >= 0; iLeft--) {
while (iRight > 0 &&
right[iRight - 1] * (maxSpeed + 1) > (maxSpeed - 1) * left[iLeft] &&
right[iRight - 1] * (maxSpeed - 1) > (maxSpeed + 1) * left[iLeft]) {
iRight--;
}
total += (long long)(right.size() - iRight);
}
printf("%lld", total);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cnt = 0, idx, b = 0;
char s[15], a[15][15] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; i++)
if (s[i] != '.') b++;
for (int i = 0; i < 8; i++)
if (strlen(a[i]) == n) {
for (int j = 0; j < n; j++)
if (a[i][j] == s[j] && s[j] != '.') cnt++;
if (cnt == b) {
idx = i;
break;
}
cnt = 0;
}
printf("%s", a[idx]);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
char p[2];
cin>>a>>p>>b;
while(p[0]!='?'){
if(p[0]=='+')cout<<a+b<<endl;
if(p[0]=='-')cout<<a-b<<endl;
if(p[0]=='*')cout<<a*b<<endl;
if(p[0]=='/')cout<<a/b<<endl;
cin>>a>>p>>b;
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.