solution
stringlengths 53
181k
| difficulty
int64 0
13
|
---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long int;
using ull = unsigned long long int;
using dd = double;
using ldd = long double;
using si = short int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
ll get_seed(string s) {
ll ans = 0;
for (int i = 0; i < s.size(); ++i) ans += s[i];
return ans;
}
int n, m;
bool **arr, **arr1;
void cp() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
arr1[i][j] = arr[i][j];
}
}
}
void inv(int j) {
for (int i = 0; i < n; i++) {
arr1[i][j] ^= 1;
}
}
bool check() {
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (arr1[i][j] != arr1[i][0]) {
return false;
}
}
}
return true;
}
bool ch(int i) {
for (int j = 1; j < m; j++) {
if (arr1[i][j] != arr1[i][0]) {
return false;
}
}
return true;
}
bool ch1(int i) {
int jj = -1;
for (int j = 1; j < m && jj == -1; j++) {
if (arr1[i][j] != arr1[i][0]) {
jj = j;
}
}
if (jj == -1) {
return true;
}
for (int j = jj + 1; j < m; j++) {
if (arr1[i][j] != arr1[i][jj]) {
return false;
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
arr = new bool *[n];
arr1 = new bool *[n];
for (int i = 0; i < n; i++) {
arr[i] = new bool[m];
arr1[i] = new bool[m];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int c;
scanf("%d", &c);
arr[i][j] = c;
}
}
bool invert[m];
for (int kek = 0; kek < m; kek++) {
cp();
for (int i = 0; i < kek; i++) {
invert[i] = false;
if (arr1[0][i] == 1) {
inv(i);
invert[i] = true;
}
}
for (int i = kek; i < m; i++) {
invert[i] = false;
if (arr1[0][i] == 0) {
inv(i);
invert[i] = true;
}
}
if (check()) {
printf("YES\n0");
for (int i = 1; i < n; i++) {
if (arr1[i][0] == 0) {
printf("1");
} else {
printf("0");
}
}
printf("\n");
for (int i = 0; i < m; i++) {
printf("%d", invert[i]);
}
return 0;
}
}
cp();
for (int i = 0; i < m; i++) {
invert[i] = false;
if (arr[0][i] == 1) {
inv(i);
invert[i] = true;
}
}
int ind = -1;
for (int i = 1; i < n && ind == -1; i++) {
if (!ch(i)) {
if (!ch1(i)) {
ind = -2;
} else {
ind = i;
}
}
}
bool flag = ind != -2;
if (ind > -1) {
for (int i = ind + 1; i < n; i++) {
flag &= ch(i);
}
}
if (flag) {
printf("YES\n0");
if (ind == -1) {
for (int i = 1; i < n; i++) {
printf("%d", arr1[i][0] ? 0 : 1);
}
} else {
for (int i = 1; i <= ind; i++) {
printf("%d", arr1[i][0] ? 1 : 0);
}
for (int i = ind + 1; i < n; i++) {
printf("%d", arr1[i][0] ? 0 : 1);
}
}
printf("\n");
for (int i = 0; i < m; i++) {
printf("%d", invert[i]);
}
return 0;
}
for (int i = 0; i < m; i++) {
arr[0][i] ^= 1;
}
for (int kek = 0; kek < m; kek++) {
cp();
for (int i = 0; i < kek; i++) {
invert[i] = false;
if (arr1[0][i] == 1) {
inv(i);
invert[i] = true;
}
}
for (int i = kek; i < m; i++) {
invert[i] = false;
if (arr1[0][i] == 0) {
inv(i);
invert[i] = true;
}
}
if (check()) {
printf("YES\n1");
for (int i = 1; i < n; i++) {
if (arr1[i][0] == 0) {
printf("1");
} else {
printf("0");
}
}
printf("\n");
for (int i = 0; i < m; i++) {
printf("%d", invert[i]);
}
return 0;
}
}
cp();
for (int i = 0; i < m; i++) {
invert[i] = false;
if (arr[0][i] == 1) {
inv(i);
invert[i] = true;
}
}
ind = -1;
for (int i = 1; i < n && ind == -1; i++) {
if (!ch(i)) {
if (!ch1(i)) {
ind = -2;
} else {
ind = i;
}
}
}
flag = ind != -2;
if (ind > -1) {
for (int i = ind + 1; i < n; i++) {
flag &= ch(i);
}
}
if (flag) {
printf("YES\n1");
if (ind == -1) {
for (int i = 1; i < n; i++) {
printf("%d", arr1[i][0] ? 0 : 1);
}
} else {
for (int i = 1; i <= ind; i++) {
printf("%d", arr1[i][0] ? 1 : 0);
}
for (int i = ind + 1; i < n; i++) {
printf("%d", arr1[i][0] ? 0 : 1);
}
}
printf("\n");
for (int i = 0; i < m; i++) {
printf("%d", invert[i]);
}
return 0;
}
printf("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char board[100][100];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> board[i][j];
if (board[0][0] == '#' || board[0][n - 1] == '#' || board[n - 1][0] == '#' ||
board[n - 1][n - 1] == '#') {
cout << "NO";
return 0;
}
for (int i = 1; i < n - 1; i++) {
for (int j = 1; j < n - 1; j++) {
if (board[i][j] == '#') {
if (board[i - 1][j] == '#' && board[i + 1][j] == '#' &&
board[i][j - 1] == '#' && board[i][j + 1] == '#') {
board[i][j] = '.';
board[i - 1][j] = '.';
board[i + 1][j] = '.';
board[i][j - 1] = '.';
board[i][j + 1] = '.';
}
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (board[i][j] == '#') {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> memo(26, vector<int>(1501, -1));
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
string s;
cin >> s;
for (int id = 0; id < 26; id++) {
for (int i = 0; i <= n; i++) {
int maxVal = 0;
int num = i;
int l = 0;
int r = 0;
for (int l = 0; r < n; l++) {
while (num > 0 && r < n) {
if (s[r] != id + 'a') num--;
r++;
}
while (num == 0 && s[r] == id + 'a') {
r++;
}
maxVal = max(maxVal, r - l);
if (s[l] != id + 'a') num++;
}
memo[id][i] = maxVal;
}
}
int q;
cin >> q;
while (q--) {
int i;
cin >> i;
char c;
cin >> c;
cout << memo[c - 'a'][i] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void FAST_IO() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
template <class F, class S>
ostream& operator<<(ostream& os, pair<F, S>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T, class S>
ostream& operator<<(ostream& os, map<T, S>& v) {
os << "{";
for (auto& i : v) cout << "{" << i.first << "," << i.second << "}";
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, set<T>& v) {
os << "{";
for (auto& i : v) cout << i << ",";
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, vector<T>& v) {
os << "[";
if (v.size()) os << v[0];
for (int i = 1; i < v.size(); ++i) os << "," << v[i];
os << "]";
return os;
}
class UF {
int *a, *sz;
int n;
public:
UF(int n) {
sz = new int[n];
a = new int[n];
this->n = n;
for (int i = 0; i < n; i++) a[i] = i, sz[i] = 1;
}
~UF() {
delete sz;
delete a;
}
int root(int p) {
while (a[p] != p) {
a[p] = a[a[p]];
p = a[p];
}
return p;
}
void merge(int p, int q) {
int i = root(p);
int j = root(q);
if (i == j) return;
if (sz[i] > sz[j])
a[j] = i, sz[i] += sz[j];
else
a[i] = j, sz[j] += sz[i];
}
bool find(int p, int q) { return root(p) == root(q); }
};
int main() {
long long n, m, k;
cin >> n >> m >> k;
UF uf(n);
for (int i = 0; i <= n - k; ++i) {
for (int j = 0; j < k / 2; ++j) {
uf.merge(i + j, (i + k - 1 - j));
}
}
set<int> groups;
for (int i = 0; i < n; ++i) groups.insert(uf.root(i));
long long resp = 1;
for (int i = 0; i < groups.size(); ++i) {
resp = (resp * m) % 1000000007LL;
}
cout << resp << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long BIGER = 1000000000000000;
const int BIG = 1000000000;
int a[23];
pair<int, int> b[23];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
b[i].first = a[i];
b[i].second = i;
}
sort(b + 1, b + 1 + n);
int t = b[1].first;
for (int i = 1; i < n; i++) b[i].first = b[i + 1].first;
b[n].first = t;
for (int i = 1; i <= n; i++) a[b[i].second] = b[i].first;
for (int i = 1; i <= n; i++) cout << a[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char now[1 << 16], *S, *T;
if (T == S) {
T = (S = now) + fread(now, 1, 1 << 16, stdin);
if (T == S) return EOF;
}
return *S++;
}
inline long long read() {
register long long x = 0, f = 1;
char ch = gc();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = gc();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = gc();
}
return (f == 1) ? x : -x;
}
long long f[1010][1010], n, m, a[101010];
signed main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) a[i] = read();
for (int i = 1; i <= m; i++) f[i][i] = 1;
for (int i = 0; i <= m + 1; i++) {
for (int j = 0; j <= m + 1; j++) {
f[i][j] = 1;
}
}
for (int len = 2; len <= m; len++) {
for (int i = 1; i + len - 1 <= m; i++) {
int j = i + len - 1, x = 0;
a[0] = n + 1;
for (int k = i; k <= j; k++) {
if (a[k] < a[x]) x = k;
}
long long tmp1 = f[i][x - 1], tmp2 = f[x + 1][j];
for (int k = i; k < x; k++) {
tmp1 = (tmp1 + f[i][k] * f[k + 1][x - 1] % 998244353) % 998244353;
}
for (int k = x + 1; k <= j; k++) {
tmp2 = (tmp2 + f[x + 1][k] * f[k + 1][j] % 998244353) % 998244353;
}
f[i][j] = tmp1 * tmp2 % 998244353;
}
}
cout << f[1][m];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T nextInt() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * p;
}
const int maxN = (int)5e2 + 10;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const long long LLINF = (long long)1e18;
char rev(char x) {
if (x == '+') return '*';
return '+';
}
vector<vector<char> > build(int k) {
vector<vector<char> > ret(1 << k, vector<char>(1 << k, '?'));
if (k == 0) {
ret[0][0] = '*';
return ret;
}
vector<vector<char> > prev = build(k - 1);
int prevsz = (1 << k) / 2;
for (int i = 0; i < prevsz; ++i) {
for (int j = 0; j < prevsz; ++j) {
ret[i][2 * j] = ret[i][2 * j + 1] = prev[i][j];
}
}
for (int j = prevsz - 1; j >= 0; --j) {
for (int i = 0; i < prevsz; ++i) {
ret[prevsz + i][2 * j + 1] = prev[i][j];
ret[prevsz + i][2 * j] = rev(prev[i][j]);
}
}
return ret;
}
int main() {
int k;
cin >> k;
vector<vector<char> > answer = build(k);
for (int i = 0; i < answer.size(); ++i) {
for (int j = 0; j < answer[i].size(); ++j) {
putchar(answer[i][j]);
}
putchar('\n');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n;
std::vector<int> v(n);
vector<int> acc(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
if (i)
acc[i] = v[i] + acc[i - 1];
else
acc[i] = v[i];
}
cin >> x >> y;
for (int i = 0; i < n; i++) {
int g1 = acc[i];
int g2 = acc[n - 1] - acc[i];
if (g1 >= x && g1 <= y && g2 >= x && g2 <= y) {
cout << i + 2;
return 0;
}
}
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int a, b, c = 0, d = 0, i, j, k = 0, l;
set<char> ss;
cin >> a;
cin >> s;
for (i = 0; i < a; i++) {
if (islower(s[i])) {
ss.insert(s[i]);
} else {
l = ss.size();
d = max(l, d);
ss.clear();
}
}
l = ss.size();
d = max(l, d);
cout << d;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ar[10010];
int main() {
int n, x;
;
scanf("%d%d", &n, &x);
;
int a = 0, b = 0;
int flag = 0;
for (int i = 0; i < n; i++) {
cin >> ar[i];
if (ar[i] == x) flag = 1;
}
sort(ar, ar + n);
a = lower_bound(ar, ar + n, x) - ar;
b = upper_bound(ar, ar + n, x) - ar;
int ans = 0;
if (flag)
b--;
else {
ans++;
n++;
}
a++;
b++;
while (1) {
int p = (n + 1) / 2;
if (p >= a && p <= b) break;
if (p > b) a++, b++;
n++;
ans++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int inst, a, b, c, cont1, cont2, recibidos1, recibidos2;
int main() {
scanf("%d", &inst);
for (int i = 0; i < inst; i++) {
scanf("%d %d %d", &a, &b, &c);
if (a == 1) {
recibidos1 += b;
cont1 += 10;
} else {
cont2 += 10;
recibidos2 += b;
}
}
if (recibidos1 >= (cont1) / 2)
printf("LIVE\n");
else
printf("DEAD\n");
if (recibidos2 >= (cont2) / 2)
printf("LIVE");
else
printf("DEAD");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
set<int> s(a, a + n);
s.erase(0);
cout << s.size();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x1, x2, y1, y2, minX, maxX, minY, maxY;
long long totArea;
cin >> n;
maxX = maxY = totArea = 0;
minX = minY = 100000000;
for (int asdfg = 0; asdfg < (n); asdfg++) {
cin >> x1 >> y1 >> x2 >> y2;
totArea += (x2 - x1) * (y2 - y1);
minX = min(minX, x1);
maxX = max(maxX, x2);
minY = min(minY, y1);
maxY = max(maxY, y2);
}
if ((maxX - minX) == (maxY - minY) &&
totArea == (maxX - minX) * 1ll * (maxY - minY))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
char s[N];
long long powx[N], powy[N];
long long hashx[N], hashy[N];
int a[N];
string ans;
bool check(int p, int q, int d) {
long long hashp = hashx[p + d] - hashx[p];
if (hashp < 0) hashp += 1000000007ll;
hashp = hashp * powx[q - p] % 1000000007ll;
long long hashq = hashx[q + d] - hashx[q];
if (hashq < 0) hashq += 1000000007ll;
if (hashp != hashq) return false;
hashp = hashy[p + d] - hashy[p];
if (hashp < 0) hashp += 1000000007ll;
hashp = hashp * powy[q - p] % 1000000007ll;
hashq = hashy[q + d] - hashy[q];
if (hashq < 0) hashq += 1000000007ll;
if (hashp != hashq) return false;
return true;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s);
powx[0] = 1;
for (int i = 0; i < n; i++) powx[i + 1] = powx[i] * 25625462 % 1000000007ll;
powy[0] = 1;
for (int i = 0; i < n; i++) powy[i + 1] = powy[i] * 46835134 % 1000000007ll;
for (int i = 0; i < n; i++)
hashx[i + 1] =
(hashx[i] + (long long)(s[i] - 'a') * powx[i]) % 1000000007ll;
for (int i = 0; i < n; i++)
hashy[i + 1] =
(hashy[i] + (long long)(s[i] - 'a') * powy[i]) % 1000000007ll;
for (int i = 0; i < n / k + 1; i++) {
int lb = 0, ub = n + 1;
while (ub - lb > 1) {
int mid = (lb + ub) >> 1;
if (i + mid <= n && check(0, i, mid))
lb = mid;
else
ub = mid;
}
int l = k * i;
int r = min(l + i, i + lb);
if (l <= r) {
a[l]++;
a[r + 1]--;
}
}
for (int i = 0; i < n; i++) a[i + 1] += a[i];
for (int i = 0; i < n; i++) ans += (a[i + 1] > 0) ? '1' : '0';
printf("%s\n", ans.c_str());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int hi1[1000000], hi2[1000000];
int main() {
int n;
cin >> n;
int a, b, c, sum = 0, yo = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (hi1[a] || hi2[b])
yo += c, hi1[b] = hi2[a] = 1;
else
hi1[a] = hi2[b] = 1;
sum += c;
}
cout << min(yo, sum - yo);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int t[710][710], t2[710][710], t3[710][710], n, m, d[710];
int main() {
scanf("%d %d", &n, &m);
while (m--) {
int a, b;
scanf("%d %d", &a, &b);
--a;
--b;
t[a][b] = t[b][a] = 1;
++d[a];
++d[b];
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
int s = 0;
for (int k = 0; k < n; k++) s += t[i][k] * t[k][j];
t2[j][i] = t2[i][j] = s;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
int s = 0;
for (int k = 0; k < n; k++)
if (k != i && k != j) s += t[i][k] * (t2[k][j] - t[i][j]);
t3[j][i] = t3[i][j] = s;
}
long long r = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
r += (long long)t2[i][j] * t3[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
r -= (long long)t2[i][j] * t[i][j] * (d[i] - 2 + d[j] - 2);
}
cout << r / 10 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const long long INFL = LLONG_MAX;
const long double pi = acos(-1);
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
vector<int> primes;
bitset<10000007> bs;
long long a[10000000 + 1];
void sieve() {
bs.reset();
bs.flip();
bs[0] = bs[1] = 0;
for (long long i = 2; i <= 10000000; i++)
if (bs[i]) {
for (long long j = i * i; j <= 10000000; j += i) {
bs[j] = 0;
}
primes.push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cout.tie(0);
cin.tie(0);
int n;
cin >> n;
vector<pair<long long, long long> > v;
for (int(i) = 0; (i) < (n); (i)++) {
int l, r;
cin >> l >> r;
v.push_back(pair<long long, long long>(l, r));
}
sort(v.begin(), v.end());
long long rg = 0, ct = 0;
for (int(i) = 0; (i) < (int((v).size())); (i)++) {
if (v[i].second < rg) {
ct++;
} else {
rg = max(v[i].second, rg);
}
}
cout << ct << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void smain();
int main() {
ios_base::sync_with_stdio(0);
smain();
return 0;
}
long long l[300], r[300], n;
long long cnt(long long i, long long x, long long mode) {
if (mode == 0) {
if (x < l[i] || x > r[i]) return 0;
return 1;
}
if (mode > 0) {
if (x <= l[i]) return (r[i] - l[i] + 1);
long long d = r[i] - x + 1;
if (d < 0) return 0;
return d;
}
if (x >= r[i]) return (r[i] - l[i] + 1);
long long d = x - l[i] + 1;
if (d < 0) return 0;
return d;
}
double solve1() {
long long mn = l[0], mx = r[0];
double q = 1;
for (long long i = 0; i < n; i++)
mn = min(mn, l[i]), mx = max(mx, r[i]), q *= (r[i] - l[i] + 1);
double res = 0;
for (long long x = mn; x <= mx; ++x) {
double r = 0;
for (long long i = 0; i < n; i++) {
double p = cnt(i, x + 1, 1), p1 = 1, p2 = 1;
for (long long k = 0; k < n; k++)
if (k != i) p1 *= cnt(k, x, -1), p2 *= cnt(k, x - 1, -1);
r += p * (p1 - p2);
}
long long mm = 1 << n;
for (long long mask = 0; mask < mm; mask++) {
if (__builtin_popcountll(mask) < 2) continue;
double p = 1;
for (long long i = 0; i < n; i++)
if (((mask >> i) & 1))
p *= cnt(i, x, 0);
else
p *= cnt(i, x - 1, -1);
r += p;
}
res += r / q * x;
}
return res;
}
double prob(long long i, long long x, long long mode) {
if (mode == 0) {
if (x < l[i] || x > r[i]) return 0;
return 1.0 / (r[i] - l[i] + 1);
}
if (mode > 0) {
if (x <= l[i]) return 1;
long long d = r[i] - x + 1;
if (d < 0) return 0;
return (double)d / (r[i] - l[i] + 1);
}
if (x >= r[i]) return 1;
long long d = x - l[i] + 1;
if (d < 0) return 0;
return (double)d / (r[i] - l[i] + 1);
}
double solve() {
long long mn = l[0], mx = r[0];
for (long long i = 0; i < n; i++) mn = min(mn, l[i]), mx = max(mx, r[i]);
double res = 0;
for (long long x = mn; x <= mx; ++x) {
double r = 0;
for (long long i = 0; i < n; i++) {
double p = prob(i, x, 1), p1 = 1, p2 = 1;
for (long long k = 0; k < n; k++)
if (k != i) p1 *= prob(k, x, -1), p2 *= prob(k, x - 1, -1);
r += p * (p1 - p2);
}
if (r > 0.00000001) res += r * x;
}
return res;
}
void smain() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> l[i] >> r[i];
cout.precision(10);
cout << fixed << solve1();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, pos = 0, zer = 0, neg = 0;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > 0)
pos++;
else if (a[i] < 0)
neg++;
else
zer++;
}
if (n % 2 == 0) {
if (pos >= n / 2) {
cout << 1;
} else if (neg >= n / 2) {
cout << -1;
} else {
cout << 0;
}
} else {
if (pos >= (n / 2) + 1) {
cout << 1;
} else if (neg >= (n / 2) + 1) {
cout << -1;
} else {
cout << 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, bool> ma;
int x, ans;
void work(int a) {
if (ma[a] == 1)
return;
else {
ans++;
ma[a] = 1;
a++;
while (a % 10 == 0) a /= 10;
work(a);
}
}
int main() {
scanf("%d", &x);
work(x);
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void PrintArray(const vector<int> &arr) {
for (int i = 0; i < arr.size(); i++) cout << arr[i] << " ";
cout << endl;
}
int main() {
std::ios::sync_with_stdio(false);
long long int a, b, c;
cin >> a >> b >> c;
if (c > 0 && b >= a) {
if ((b - a) % c == 0) {
cout << "YES" << endl;
return 0;
} else
cout << "NO" << endl;
} else if (c < 0 && b <= a) {
int temp = abs(c);
if ((a - b) % temp == 0) {
cout << "YES" << endl;
return 0;
} else
cout << "NO" << endl;
} else if (c == 0) {
if (a == b) {
cout << "YES" << endl;
return 0;
} else
cout << "NO" << endl;
} else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char str[60], s[1123][60], t[60];
int po[60], vis[300], v[1123][300], c[300];
int main() {
int n, m, i, k, j;
while (~scanf("%d", &n)) {
int num = 0, ans = 0, we = 0;
memset(vis, 0, sizeof(vis));
memset(c, 0, sizeof(c));
scanf("%s", str);
for (i = 0; i < n; i++) {
if (str[i] == '*')
po[num++] = i;
else
vis[str[i]]++;
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%s", t);
for (j = 0; j < n; j++) {
if (str[j] != t[j] && str[j] == '*' && !vis[t[j]])
continue;
else if (str[j] == t[j])
continue;
break;
}
if (j == n) strcpy(s[ans++], t);
}
memset(v, 0, sizeof(v));
for (k = 0; k < ans; k++) {
for (i = 0; i < num; i++) {
int pos = po[i];
v[k][s[k][pos]]++;
}
}
int sum = 0;
for (i = 'a'; i <= 'z'; i++) {
sum = 0;
for (j = 0; j < ans; j++) {
if (v[j][i]) sum += 1;
}
if (sum == ans) we++;
}
printf("%d\n", we);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int b, p, f, h, c, profit = 0;
scanf("%d %d %d", &b, &p, &f);
scanf("%d %d", &h, &c);
if (b <= 1) {
printf("%d\n", profit);
} else {
b = b / 2 * 2;
if (c > h) {
int temp = h;
h = c;
c = temp;
temp = p;
p = f;
f = temp;
}
if (h >= c) {
if (2 * p >= b)
profit = b / 2 * h;
else {
if ((b - (p * 2)) > 2 * f)
profit = p * h + f * c;
else
profit = p * h + (b - (2 * p)) / 2 * c;
}
}
printf("%d\n", profit);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1& a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1& a, T2 b) {
return a > b ? a = b, 1 : 0;
}
const int N = 100, inf = 1e9 + 1;
int fast[N], slow[N], p[N];
int n, cap;
bool lt(double m) {
vector<double> f(cap + 1, 0);
int mx = cap + 1;
for (int i = n - 1; i >= (0); --i) {
for (int t = 0; t < (mx); ++t) {
if (t + fast[i] >= mx) {
mx = t;
break;
}
double v = (fast[i] + f[t + fast[i]]) * p[i];
v += (slow[i] + (t + slow[i] >= mx ? m : f[t + slow[i]])) * (100 - p[i]);
v /= 100;
if (v >= m) {
mx = t;
break;
}
f[t] = v;
}
}
return mx;
}
void solve() {
cin >> n >> cap;
for (int i = 0; i < (n); ++i) cin >> fast[i] >> slow[i] >> p[i];
double l = 0, r = 1e9;
for (int it = 0; it < (60); ++it) {
double m = (l + r) / 2;
if (lt(m))
r = m;
else
l = m;
}
cout << l << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N1 = (int)(1e6 + 0.5);
const long long N2 = (long long)(1e12 + 0.5);
struct emt {
long long a, cost;
};
bool cmp(emt u, emt v) { return u.cost < v.cost; }
emt e[N1 + 5];
unordered_map<long long, int> CNT;
long long gcd(long long x, long long y) { return !x ? y : gcd(y % x, x); }
vector<long long> decomdd;
int prime_decomp_dd(long long x) {
for (int y = 2; y <= N1; y++) {
if (x % y) continue;
decomdd.push_back(y);
while (x % y == 0) x /= y;
}
if (x > 1) decomdd.push_back(x);
return decomdd.size();
}
long long prime_decomp_a(long long x) {
long long t = 1;
for (long long y : decomdd)
while (x % y == 0) x /= y, t *= y;
return t;
}
long long dp[12][1 << 11], dp1[12][1 << 11];
void work(int S, long long cost, int LEN) {
int S1 = ((1 << LEN) - 1) ^ S;
for (int i = 1; i <= LEN; i++) {
for (int j = S1; j; j = (j - 1) & S1)
dp[i][j | S] = min(dp[i][j | S], dp1[i - 1][j] + cost);
dp[i][S] = min(dp[i][S], dp1[i - 1][0] + cost);
}
}
int used[1 << 11];
int main() {
int n;
long long K, dd = 0;
cin >> n >> K;
for (int i = 1; i <= n; i++) {
scanf("%lld", &e[i].a);
dd = gcd(dd, e[i].a);
}
if (dd == 1) {
puts("0");
return 0;
}
int LEN = prime_decomp_dd(dd);
for (int i = 1; i <= n; i++) {
scanf("%lld", &e[i].cost);
e[i].a = prime_decomp_a(e[i].a);
}
sort(e + 1, e + n + 1, cmp);
memset(dp, 1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
if (++CNT[e[i].a] > LEN) continue;
long long mul[11], prod[1 << 11];
prod[0] = 1;
for (int j = 0; j < LEN; j++) {
mul[j] = 1;
while (e[i].a % decomdd[j] == 0)
e[i].a /= decomdd[j], mul[j] *= decomdd[j];
}
bool FST = 0;
for (int j = 0; j < LEN; j++) {
for (int k = (1 << j); k < (1 << (j + 1)); k++) {
prod[k] = prod[k ^ (1 << j)] * mul[j];
if (prod[k] <= K && used[k]++ < LEN) {
if (!FST) memcpy(dp1, dp, sizeof(dp1)), FST = 1;
work(k, e[i].cost, LEN);
}
}
}
}
long long ans = 1e13;
for (int i = 1; i <= LEN; i++) ans = min(ans, dp[i][(1 << LEN) - 1] * i);
if (ans >= 1e13) ans = -1;
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> in;
vector<pair<int, int> > min_max;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
in.push_back(x);
}
vector<int> out;
out.push_back(in[0]);
int ctr = 1;
for (int i = 1; i < n - 1; i++) {
if (in[i] > in[i - 1] && in[i] > in[i + 1] ||
in[i] < in[i - 1] && in[i] < in[i + 1]) {
ctr++;
out.push_back(in[i]);
}
}
out.push_back(in[n - 1]);
ctr++;
cout << ctr << endl;
for (int i = 0; i < ctr; i++) {
cout << out[i] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long N = 1e6 + 10;
long long t[N * 4];
vector<long long> g[N];
long long u[N];
long long d[N];
long long a[N];
long long pos[N];
long long dop[N];
vector<long long> vec;
void push(long long v, long long vl, long long vr) {
if (vl <= vr) {
if (dop[v] != 0) {
t[v] = vr - vl + 1 - t[v];
if (vl != vr) {
dop[v * 2] ^= 1;
dop[v * 2 + 1] ^= 1;
}
dop[v] = 0;
}
}
}
void build(long long v, long long vl, long long vr) {
if (vl > vr) return;
if (vl == vr) {
t[v] = a[vec[vl]];
return;
}
long long mid = (vl + vr) / 2;
build(v * 2, vl, mid);
build(v * 2 + 1, mid + 1, vr);
t[v] = t[v * 2] + t[v * 2 + 1];
}
void dfs(long long v) {
u[v] = 1;
d[v] = 1;
vec.push_back(v);
for (auto to : g[v])
if (!u[to]) {
dfs(to);
d[v] += d[to];
}
}
void upd(long long v, long long vl, long long vr, long long l, long long r) {
push(v, vl, vr);
if (vl > vr || vl > r || vr < l) return;
if (vl >= l && vr <= r) {
dop[v] ^= 1;
push(v, vl, vr);
return;
}
push(v, vl, vr);
long long mid = (vl + vr) / 2;
upd(v * 2, vl, mid, l, r);
upd(v * 2 + 1, mid + 1, vr, l, r);
t[v] = t[v * 2] + t[v * 2 + 1];
}
long long sum(long long v, long long vl, long long vr, long long l,
long long r) {
push(v, vl, vr);
if (vl > vr || vl > r || vr < l) return 0;
if (vl >= l && vr <= r) {
push(v, vl, vr);
return t[v];
}
push(v, vl, vr);
long long mid = (vl + vr) / 2;
return sum(v * 2, vl, mid, l, r) + sum(v * 2 + 1, mid + 1, vr, l, r);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 1; i < n; i++) {
long long p;
cin >> p;
p--;
g[i].push_back(p);
g[p].push_back(i);
}
dfs(0);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) pos[vec[i]] = i;
build(1, 0, n - 1);
long long q;
cin >> q;
while (q--) {
string tp;
cin >> tp;
if (tp == "pow") {
long long x;
cin >> x;
x--;
upd(1, 0, n - 1, pos[x], pos[x] + d[x] - 1);
} else {
long long x;
cin >> x;
x--;
cout << sum(1, 0, n - 1, pos[x], pos[x] + d[x] - 1) << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template <typename A, typename B>
inline void chmin(A& a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A& a, B b) {
if (a < b) a = b;
}
const int32 DIRECTED = 0;
const int32 UNDIRECTED = 1;
template <int32 isUNDIRECTED = 0>
class Graph {
struct Edge {
int32 u, v, id;
int64 c;
Edge(int32 u, int32 v, int64 c = 0, int32 id = 0)
: u(u), v(v), c(c), id(id) {}
};
int32 V, E;
vector<vector<Edge>> G;
vector<Edge> Es;
public:
Graph() {}
Graph(int32 V) : V(V) { G.resize(V); }
Graph(const Graph<isUNDIRECTED>& g) : V(g.V), E(g.E), G(g.G), Es(g.Es) {}
void add_edge(int32 u, int32 v, int64 c = 0, int32 id = 0) {
G[u].emplace_back(u, v, c, id);
if (isUNDIRECTED) G[v].emplace_back(v, u, c, id);
Es.emplace_back(u, v, c, id);
E++;
}
const vector<Edge>& operator[](int32 k) { return G[k]; }
};
class SCC {
private:
Graph<DIRECTED> orgG, revG, newG;
vector<int32> ord, comp;
vector<bool> used;
vector<vector<int32>> vs;
int32 V, nV;
public:
SCC() {}
SCC(int32 V) : orgG(V), revG(V), comp(V, -1), used(V, 0), V(V) {}
void add_edge(int32 u, int32 v) {
orgG.add_edge(u, v);
revG.add_edge(v, u);
}
void dfs(int32 v) {
used[v] = true;
for (auto e : orgG[v]) {
if (!used[e.v]) dfs(e.v);
}
ord.push_back(v);
}
void rdfs(int32 v, int32 k) {
used[v] = true;
comp[v] = k;
for (auto e : revG[v]) {
if (!used[e.v]) rdfs(e.v, k);
}
}
int32 build() {
for (int32 i = 0; i < V; i++) {
if (!used[i]) dfs(i);
}
fill(used.begin(), used.end(), 0);
int32 k = 0;
for (int32 i = ord.size() - 1; i >= 0; i--) {
if (!used[ord[i]]) rdfs(ord[i], k++);
}
nV = k;
vs.resize(k, vector<int32>());
for (int32 i = 0; i < V; i++) vs[comp[i]].push_back(i);
newG = Graph<DIRECTED>(k);
for (int32 i = 0; i < V; i++) {
for (auto e : orgG[i]) {
if (comp[i] != comp[e.v]) newG.add_edge(comp[i], comp[e.v], e.c);
}
}
return k;
}
int32 size() { return nV; }
const Graph<DIRECTED>& graph() { return newG; }
const vector<int32>& vertices(int32 v) { return vs[v]; }
int32 operator[](int32 k) { return comp[k]; }
};
SCC scc;
int32 n, m, h;
int32 u[112345];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> h;
for (int i = 0; i < (n); i++) cin >> u[i];
scc = SCC(2 * n);
for (int i = 0; i < (n); i++) {
scc.add_edge(i, i + n);
}
for (int i = 0; i < (m); i++) {
int32 a, b;
cin >> a >> b;
a--;
b--;
if ((u[a] + 1) % h == u[b]) scc.add_edge(a + n, b);
if ((u[b] + 1) % h == u[a]) scc.add_edge(b + n, a);
}
scc.build();
Graph<DIRECTED> G = scc.graph();
vector<bool> visited(scc.size(), 0);
vector<int32> dp(scc.size(), -1);
int32 res_s = (int)1e9;
vector<int32> res;
function<void(int32)> dfs = [&](int32 v) {
if (G[v].size() == 0) {
vector<int32> a = scc.vertices(v);
if (res_s > a.size()) {
res_s = a.size();
res = a;
}
return;
}
for (auto e : G[v]) {
if (!visited[e.v]) {
visited[e.v] = 1;
dfs(e.v);
}
}
};
for (int i = 0; i < (scc.size()); i++) {
if (!visited[i]) {
dfs(i);
}
}
cout << (res.size() + res.size() % 2) / 2 << endl;
for (int i = 0; i < (res.size()); i++) {
if (res[i] >= n) cout << res[i] - n + 1 << " ";
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long int, long long int>, long long int> m;
long long int nCr(long long int n, long long int r) {
if (n == r) return 1;
if (r == 0) return 1;
if (n < r) return 0;
if (m.count({n, r}) == 1) return m[{n, r}];
return m[{n, r}] = nCr(n - 1, r - 1) + nCr(n - 1, r);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m, h;
cin >> n >> m >> h;
vector<long long int> s(m);
for (long long int i = 0; i < m; i++) cin >> s[i];
long long int sum = 0;
for (long long int i = 0; i < m; i++) sum += s[i];
if (sum < n) {
cout << -1;
return 0;
}
long long int sh = s[h - 1];
double ans = 1;
if (sum - sh < n - 1)
ans = 0;
else {
long long int a = sum - sh;
long long int b = a - n + 1;
for (long long int i = 1; i < sh; i++) {
ans *= 1.0 * (b + i) / (a + i);
}
}
cout << std::setprecision(12) << (1 - ans) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int answer(long long int bx, long long int by, long long int cx,
long long int cy);
int main(void) {
struct vector {
long long int x;
long long int y;
} a, b, c, d;
int flg, j, k;
scanf("%I64d %I64d", &a.x, &a.y);
scanf("%I64d %I64d", &b.x, &b.y);
scanf("%I64d %I64d", &c.x, &c.y);
flg = 0;
flg += answer(b.x - a.x, b.y - a.y, c.x, c.y);
flg += answer(b.x + a.y, b.y - a.x, c.x, c.y);
flg += answer(b.x + a.x, b.y + a.y, c.x, c.y);
flg += answer(b.x - a.y, b.y + a.x, c.x, c.y);
if (flg == 0)
puts("NO");
else
puts("YES");
return 0;
}
int answer(long long int bx, long long int by, long long int cx,
long long int cy) {
long long int tmp;
if (cx == 0 && cy == 0) {
if (bx == 0 && by == 0) return 1;
return 0;
}
if (cx == 0) {
if (bx % cy == 0 && by % cy == 0) return 1;
return 0;
} else if (cy == 0) {
if (bx % cx == 0 && by % cx == 0) return 1;
return 0;
} else {
tmp = cx * cx + cy * cy;
if ((bx * cx + by * cy) % tmp == 0 && (by * cx - bx * cy) % tmp == 0)
return 1;
return 0;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], value[100005], que[100105];
vector<int> relation[100005], ans;
int main() {
int n, m, i, j, frnt, rear, now;
while ((scanf("%d %d", &n, &m)) != EOF) {
frnt = 0;
rear = 0;
while (m--) {
scanf("%d %d", &i, &j);
relation[i].push_back(j);
relation[j].push_back(i);
}
for (i = 1; i <= n; i++) {
value[i] = 0;
scanf("%d", &a[i]);
if (!a[i]) que[rear++] = i;
}
while (frnt != rear) {
now = que[frnt++];
if (a[now] == value[now]) {
value[now]++;
ans.push_back(now);
for (i = 0; i < relation[now].size(); i++) {
j = relation[now][i];
value[j]++;
if (value[j] == a[j]) que[rear++] = j;
}
}
}
printf("%d\n", ans.size());
if (ans.size() > 0) {
printf("%d", ans[0]);
for (i = 1; i < ans.size(); i++) printf(" %d", ans[i]);
printf("\n");
}
ans.clear();
for (i = 1; i <= n; i++) relation[i].clear();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
long long d1, d2, d3, d;
scanf("%I64d%I64d%I64d", &d1, &d2, &d3);
if (d1 > d2 && d1 > d3)
d = 2 * (d2 + d3);
else if (d2 > d3 && d2 > d1)
d = 2 * (d1 + d3);
else if (d3 > d1 && d3 > d2 && d3 > (d1 + d2))
d = 2 * (d1 + d2);
else
d = d1 + d2 + d3;
printf("%I64d", d);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
long long n;
inline void orz(long long a, long long b, long long c, long long d, long long e,
long long f);
inline void orz(long long a, long long b, long long c, long long d) {
long long x, y;
int p;
x = (long long)(a + 0.2 * (b - a) + eps);
y = (long long)(c + 0.2 * (d - c) + eps);
cout << x << " " << y << endl;
fflush(stdout);
cin >> p;
if (!p) return;
if (p == 1) orz(x + 1, b, c, d);
if (p == 2) orz(a, b, y + 1, d);
if (p == 3) orz(a, b, c, d, x - 1, y - 1);
}
inline void orz(long long a, long long b, long long c, long long d, long long e,
long long f) {
if (a > e) {
orz(a, b, c, f);
return;
}
if (c > f) {
orz(a, e, c, d);
return;
}
long long x, y;
int p;
x = (long long)(a + 0.8 * (e - a) + eps);
y = (long long)(c + 0.8 * (f - c) + eps);
cout << x << " " << y << endl;
fflush(stdout);
cin >> p;
if (!p) exit(0);
if (p == 1) orz(x + 1, b, c, d, e, f);
if (p == 2) orz(a, b, y + 1, d, e, f);
if (p == 3) orz(a, b, c, d, x - 1, y - 1);
}
int main() {
cin >> n;
orz(1, n, 1, n);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x[n];
int h[n];
for (int i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
if (n == 1) {
cout << 1 << "\n";
} else if (n == 2) {
cout << 2 << "\n";
} else {
int fall[n];
fall[0] = x[0];
fall[n - 1] = x[n - 1];
int cnt = 2;
for (int i = 1; i < n - 1; i++) {
if (h[i] < (x[i] - fall[i - 1])) {
fall[i] = x[i];
cnt++;
} else if (h[i] < x[i + 1] - x[i]) {
fall[i] = x[i] + h[i];
cnt++;
} else {
fall[i] = x[i];
}
}
cout << cnt << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
long long a[N];
int32_t bit_cnt[N];
long long dp[N][2];
int32_t prefix_sum[N];
void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
bit_cnt[i] = __builtin_popcountll(a[i]);
}
for (long long i = 1; i <= n; ++i) {
prefix_sum[i] = bit_cnt[i] + prefix_sum[i - 1];
}
long long ans = 0;
dp[0][0] = 1;
for (long long i = 1; i <= n; ++i) {
long long c = prefix_sum[i] & 1LL;
dp[i][0] = dp[i - 1][0];
dp[i][1] = dp[i - 1][1];
dp[i][c] += 1;
ans += dp[i - 1][c];
long long res = -1, mx = bit_cnt[i];
long long sum = 0;
for (long long j = i; i - j <= 62 && j > 0; --j) {
mx = max(mx, (long long)bit_cnt[j]);
sum += bit_cnt[j];
if ((sum - mx < mx) && (sum & 1) == 0) {
--ans;
}
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 1; i <= t; ++i) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, count = 0, j, max = -9999, r;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
cin >> m;
int b[m];
for (i = 0; i < m; i++) cin >> b[i];
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (b[i] % a[j] == 0) r = b[i] / a[j];
if (r > max) max = r;
}
}
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (b[i] % a[j] == 0 && b[i] / a[j] == max) count++;
}
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int lmt = 5005;
char grid[lmt][lmt];
int cnt[lmt][lmt];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", grid[i]);
for (int i = 0; i < n; i++) {
for (int j = m - 1; j >= 0; j--) {
if (grid[i][j] == '0')
cnt[i][j] = 0;
else
cnt[i][j] = cnt[i][j + 1] + 1;
}
}
int ans = 0;
vector<int> v;
for (int j = 0; j < m; j++) {
v.clear();
for (int i = 0; i < n; i++) v.push_back(cnt[i][j]);
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) ans = max(ans, v[i] * (n - i));
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MAXM = 1000005;
const int MOD = 1000000007;
const int MAMOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
long long n, p;
int gao(long long x) {
int cnt = 0;
while (x) {
x ^= x & -x;
cnt++;
}
return cnt;
}
int main() {
scanf("%lld%lld", &n, &p);
for (long long i = 1; i <= MAXM; i++)
if (n - p * i >= i && gao(n - p * i) <= i) {
printf("%lld\n", i);
return 0;
}
printf("-1\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[105];
void reverse(int l, int r) {
while (l < r) {
swap(s[l], s[r]);
l++;
r--;
}
}
int main() {
scanf("%d", &n);
scanf("%s", s);
stack<int> st;
for (int i = n; i >= 1; i--) {
if (n % i == 0) st.push(i);
}
while (!st.empty()) {
reverse(0, st.top() - 1);
st.pop();
}
printf("%s\n", s);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cum(string s, string t) {
int ps = 0, pt = 0, num = 0;
while (ps < s.size() && pt < t.size()) {
if (s[ps] == t[pt]) {
num++;
pt++;
}
ps++;
}
return s.size() - num - num + t.size();
}
int main() {
int t;
ios::sync_with_stdio(false);
cin >> t;
vector<string> sz;
long long int x = 1;
while (x <= (long long)2e18) {
sz.push_back(to_string(x));
x = x * 2;
}
while (t--) {
string n;
cin >> n;
int ans = n.length() + 1;
for (auto t : sz) {
ans = min(ans, cum(n, t));
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 9;
const int maxnode = 2000;
int n, m;
int ch[maxnode][26], tot = 0, f[maxnode], last[maxnode], val[maxnode],
dp[1007][201][11];
char s[20];
void ins(char *s, int len) {
int u = 0;
for (int i = int(0); i <= int(len - 1); ++i) {
int c = s[i] - 'A';
if (!ch[u][c]) ch[u][c] = ++tot;
u = ch[u][c];
}
val[u] = len;
}
void build() {
queue<int> q;
f[0] = 0;
for (int i = int(0); i <= int(25); ++i) {
int u = ch[0][i];
if (u) {
f[u] = last[u] = 0;
q.push(u);
}
}
while (!q.empty()) {
int r = q.front();
q.pop();
for (int i = int(0); i <= int(25); ++i) {
int u = ch[r][i];
if (!u) {
ch[r][i] = ch[f[r]][i];
continue;
}
q.push(u);
int v = f[r];
while (v && !ch[v][i]) v = f[v];
f[u] = ch[v][i];
last[u] = val[f[u]] ? f[u] : last[f[u]];
val[u] = max(val[u], val[last[u]]);
}
}
}
char DNA[4] = {'A', 'C', 'G', 'T'};
int main() {
int n, m;
cin >> n >> m;
for (int i = int(1); i <= int(m); ++i) {
scanf("%s", s);
int len = strlen(s);
ins(s, len);
}
build();
dp[0][0][0] = 1;
for (int i = int(0); i <= int(n); ++i)
for (int j = int(0); j <= int(tot); ++j)
for (int k = int(0); k <= int(9); ++k)
if (dp[i][j][k]) {
for (int l = int(0); l <= int(3); ++l) {
int c = DNA[l] - 'A';
int nxt = ch[j][c];
if (val[nxt] >= k + 1)
(dp[i + 1][nxt][0] += dp[i][j][k]) %= MOD;
else
(dp[i + 1][nxt][k + 1] += dp[i][j][k]) %= MOD;
}
}
int ans = 0;
for (int i = int(0); i <= int(tot); ++i) (ans += dp[n][i][0]) %= MOD;
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long i, j;
long long n, k;
cin >> n >> k;
vector<long long> x(n);
long long maxx = k;
long long index = -1;
for (i = (0); i < (n); i++) {
cin >> x[i];
maxx = max(maxx, x[i]);
}
long long a;
cin >> a;
vector<long long> c(n);
for (i = (0); i < (n); i++) cin >> c[i];
priority_queue<long long, vector<long long>, greater<long long>> cs;
long long cost = 0;
long long current = k;
for (i = (0); i < (n); i++) {
cs.push(c[i]);
while (current < x[i] && !cs.empty()) {
long long top = cs.top();
cs.pop();
current += a;
cost += top;
}
if (current < x[i]) {
cout << "-1" << '\n';
return 0;
}
}
cout << cost << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4004;
int arr[N][N];
int cum[N][N];
int n, k;
int val[N][N];
int memo[3][N];
int getcum(int f, int t) {
return cum[t][t] - cum[t][f - 1] - cum[f - 1][t] + cum[f - 1][f - 1];
}
void solve(bool l, int s, int e, int f, int t) {
if (s > e) return;
int mid = s + (e - s) / 2;
int &r = memo[l][mid];
r = 1e9;
int end = min(mid, t);
int best = end;
int cur = 0;
for (int b = end; b >= f; --b) {
cur = memo[!l][b - 1] + val[b][mid];
if (cur < r) {
r = cur;
best = b;
}
}
solve(l, s, mid - 1, f, best);
solve(l, mid + 1, e, best, t);
}
int getINT() {
char c;
int ret = 0;
while (true) {
c = getchar();
if (c < '0' || c > '9') break;
ret = (ret << 1) + (ret << 3) + (c - '0');
}
return ret;
}
int main() {
n = getINT();
k = getINT();
for (int i = 1; i <= n; ++i) {
memo[0][i] = 1e9;
for (int j = 1; j <= n; ++j) {
arr[i][j] = getINT();
cum[i][j] = arr[i][j];
cum[i][j] =
(cum[i][j] + cum[i - 1][j] + cum[i][j - 1] - cum[i - 1][j - 1]);
}
}
for (int i = 1; i < n; ++i) {
for (int j = i + 1; j <= n; ++j) {
val[i][j] = getcum(i, j);
}
}
for (int v = 1; v <= k; ++v) {
solve(v & 1, 1, n, 1, n);
}
printf("%d", memo[k & 1][n] / 2);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long long modpow(long long b, long long e, long long m) {
long long r = 1;
while (e) {
if (e % 2) {
r *= b;
r %= m;
}
b *= b;
b %= m;
e /= 2;
}
return r;
}
int n, m, k;
long long l[500005];
int ufpar[500005];
int find(int x) { return ufpar[x] == x ? x : (ufpar[x] = find(ufpar[x])); }
bool merge(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx == fy) return false;
ufpar[fx] = fy;
return true;
}
void ufreset(vector<int>& v) {
for (int out : v) {
ufpar[out] = out;
}
}
map<long long, vector<pair<int, int>>> edges;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &l[i]);
}
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
edges[l[a] ^ l[b]].push_back(pair<int, int>(a, b));
}
long long twopow = modpow(2, n, MOD);
long long ret = (1LL << k);
ret %= MOD;
ret *= twopow;
ret %= MOD;
for (auto out : edges) {
ret += MOD - twopow;
if (ret >= MOD) ret -= MOD;
int nc = n;
{
vector<int> all;
for (pair<int, int> out2 : out.second) {
all.push_back(out2.first);
all.push_back(out2.second);
}
ufreset(all);
}
for (pair<int, int> out2 : out.second) {
int lhs = find(out2.first);
int rhs = find(out2.second);
if (merge(lhs, rhs)) nc--;
}
ret += modpow(2, nc, MOD);
if (ret >= MOD) ret -= MOD;
}
printf("%lld\n", ret);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
pair<int, int> device[100005];
bool valid(double mi) {
int i, j;
double req, available, tot = mi * p;
for (i = 0; i < n; i++) {
req = mi * device[i].first;
available = device[i].second;
if (req <= available)
continue;
else if ((req - available) > tot)
return false;
else if ((req - available) <= tot)
tot -= (req - available);
}
return true;
}
int main() {
int i, j;
double lo, hi, mi, ans = 0;
scanf("%d %d", &n, &p);
for (i = 0; i < n; i++) {
scanf("%d %d", &device[i].first, &device[i].second);
}
lo = 0;
hi = 1e14;
for (i = 0; i < 100; i++) {
mi = (hi + lo) * 0.5;
if (valid(mi)) {
ans = max(ans, mi);
lo = mi + 0.00000001;
} else {
hi = mi - 0.00000001;
}
}
if (ans >= 1e13)
printf("-1\n");
else
printf("%.7lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-22L;
int sgn(long double t) { return abs(t) < EPS ? 0 : (t > 0) - (t < 0); }
struct PT {
long double x, y;
PT(long double x = 0, long double y = 0) : x(x), y(y) {}
PT operator-(PT o) { return PT(x - o.x, y - o.y); }
PT operator*(long double t) { return PT(x * t, y * t); }
PT operator/(long double t) { return PT(x / t, y / t); }
PT operator+(PT o) { return PT(x + o.x, y + o.y); }
bool operator<(const PT& o) const {
int dx = sgn(x - o.x);
return dx == 0 ? sgn(y - o.y) < 0 : dx < 0;
}
bool operator==(const PT& o) const {
return sgn(x - o.x) == 0 && sgn(y - o.y) == 0;
}
};
long double dot(PT u, PT v) { return u.x * v.x + u.y * v.y; }
long double cross(PT u, PT v) { return u.x * v.y - v.x * u.y; }
long double orient(PT a, PT b, PT c) { return cross(b - a, c - a); }
long double abs(PT p) { return hypot(p.x, p.y); }
vector<PT> solve(vector<PT>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
int n = v.size();
vector<PT> h;
int i = 0, j = 1;
for (int k = 0; k < n; k++) {
while (i > j && sgn(orient(h[i - 2], h[i - 1], v[k])) < 0) {
h.resize(--i);
}
h.resize(++i, v[k]);
}
while (i > 1 && sgn(h[i - 1].y - h[i - 2].y) >= 0) {
h.resize(--i);
}
return h;
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<PT> v;
map<PT, vector<int> > mult;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
PT p(x, y);
p.x = 1.0L / p.x;
p.y = 1.0L / p.y;
v.push_back(p);
mult[p].push_back(i);
}
auto h = solve(v);
vector<int> ans;
for (PT& p : h) {
for (int k : mult[p]) ans.push_back(k);
}
sort(ans.begin(), ans.end());
for (int k : ans) cout << k << ' ';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const double PI = acos(-1);
long long n, r, h, sol;
pair<long long, int> cake[MAXN];
long long tree[4 * MAXN];
void pull(int node) {
tree[node] = max(tree[2 * node + 1], tree[2 * node + 2]);
}
void update(int node, int b, int e, int idx, long long val) {
if (b == e)
tree[node] = val;
else {
int m = (b + e) / 2;
if (idx <= m) update(2 * node + 1, b, m, idx, val);
if (idx > m) update(2 * node + 2, m + 1, e, idx, val);
pull(node);
}
}
long long query(int node, int b, int e, int i, int j) {
if (i <= b && e <= j) return tree[node];
int m = (b + e) / 2;
long long q = 0;
if (i <= m) q = max(q, query(2 * node + 1, b, m, i, j));
if (j > m) q = max(q, query(2 * node + 2, m + 1, e, i, j));
return q;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> r >> h;
cake[i].first = r * r * h;
cake[i].second = -i;
}
sort(cake, cake + n);
for (int i = 0; i < n; i++) {
long long v = query(0, 0, n - 1, 0, -cake[i].second);
update(0, 0, n - 1, -cake[i].second, v + cake[i].first);
sol = max(sol, v + cake[i].first);
}
cout << PI * sol << '\n';
;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l[501], w[501], h[501], m;
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i] >> w[i] >> h[i];
cin >> m;
int a[501], b[501], cost[501];
int c[501];
for (int i = 0; i < m; i++) cin >> a[i] >> b[i] >> cost[i];
int strips, p, roll;
long long sum = 0;
for (int i = 0; i < n; i++) {
int minc = 99999999;
for (int j = 0; j < m; j++) {
if (h[i] > a[j]) continue;
p = 2 * (l[i] + w[i]);
strips = (int)a[j] / h[i];
float d = (float)p / (strips * b[j]);
roll = ceil(d);
int co = roll * cost[j];
if (co < minc) minc = co;
}
sum += minc;
}
cout << sum << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, s = 0;
char ch = 'r';
cin >> n >> a >> b >> c;
while (--n) {
if (ch == 'r') {
if (a < b) {
s += a;
ch = 'o';
} else {
s += b;
ch = 'e';
}
} else {
if (ch == 'e') {
if (b < c) {
s += b;
ch = 'r';
} else {
s += c;
ch = 'o';
}
} else {
if (ch == 'o') {
if (c < a) {
s += c;
ch = 'e';
} else {
s += a;
ch = 'r';
}
}
}
}
}
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
int n, m;
int main() {
cin >> n >> m;
if (n > m) swap(n, m);
if (n == 1)
cout << m << endl;
else if (n == 2)
cout << (m / 4) * 4 + 2 * min(m % 4, 2) << endl;
else
cout << ((n * m + 1) / 2) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isEquivalent(string &a, string &b, int la, int ra, int lb, int rb) {
int size = ra - la + 1;
int ma = (ra + la) / 2;
int mb = (rb + lb) / 2;
if (size <= 0) return false;
if (size == 1 && (a[la] == b[lb])) {
return true;
} else if (size == 1)
return false;
if (a.compare(la, size, b, lb, size) == 0) return true;
if (size % 2 == 1) return false;
if (isEquivalent(a, b, la, ma, lb, mb) &&
isEquivalent(a, b, ma + 1, ra, mb + 1, rb))
return true;
if (isEquivalent(a, b, la, ma, mb + 1, rb) &&
isEquivalent(a, b, ma + 1, ra, lb, mb))
return true;
return false;
}
int main() {
string a, b;
getline(cin, a);
getline(cin, b);
if (isEquivalent(a, b, 0, a.size() - 1, 0, b.size() - 1))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long ans = 1, a = 0;
for (long long i = 1; i <= n; i++) {
int x;
cin >> x;
if (x == 1 && a != 0) {
ans *= (i - a);
a = i;
} else if (x == 1)
a = i;
}
if (a == 0)
cout << 0;
else
cout << ans;
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
int T,n,x,y;
int main()
{
cin>>T;
while (T--)
{
cin>>n;
vector<int>xa,ya;
for (int i=1;i<=n+n;i++)
{
cin>>x>>y;
if (x==0) ya.push_back(abs(y));
else xa.push_back(abs(x));
}
sort(xa.begin(),xa.end());
sort(ya.begin(),ya.end());
double ans=0;
for (int i=0;i<n;i++)
{
double x=xa[i],y=ya[i];
ans+=sqrt(x*x+y*y);
}
printf("%.15lf\n",ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dis[10007][1007];
bool odw[10007][1007];
int tab[10007];
deque<pair<int, int> > kolejka;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, g, r;
cin >> n >> m;
int tab1[n];
for (int i = 0; i < m; i++) cin >> tab1[i];
sort(tab1, tab1 + m);
for (int i = 1; i <= m; i++) tab[i] = tab1[i - 1];
cin >> g >> r;
kolejka.push_back(make_pair(1, 0));
int res = 1000000007;
while (kolejka.size() > 0) {
int p = kolejka[0].first;
int t = kolejka[0].second;
kolejka.pop_front();
if (p == 0 || p == m + 1) {
continue;
}
if (t == g) {
if (odw[p][0] == 0) {
dis[p][0] = dis[p][t] + 1;
kolejka.push_back(make_pair(p, 0));
odw[p][0] = 1;
}
}
if (t == 0 && tab[m] - tab[p] <= g) {
res = min(res, (g + r) * dis[p][t] + tab[m] - tab[p]);
}
int t1 = t + tab[p] - tab[p - 1];
if (t1 <= g && !odw[p - 1][t1]) {
kolejka.push_front(make_pair(p - 1, t1));
odw[p - 1][t1] = 1;
dis[p - 1][t1] = dis[p][t];
}
t1 = t + tab[p + 1] - tab[p];
if (t1 <= g && !odw[p + 1][t1]) {
kolejka.push_front(make_pair(p + 1, t1));
odw[p + 1][t1] = 1;
dis[p + 1][t1] = dis[p][t];
}
}
if (res == 1000000007)
cout << -1;
else
cout << res;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, p;
long long d[N], h[N], t[N], a[N], sumd[N], sum[N];
long long f[N][110];
int q[N];
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i < n; i++) {
scanf("%lld", &d[i]);
sumd[i + 1] = sumd[i] + d[i];
}
for (int i = 1; i <= m; i++) {
scanf("%lld%lld", &h[i], &t[i]);
a[i] = t[i] - sumd[h[i]];
}
sort(a + 1, a + 1 + m);
for (int i = 1; i <= m; i++) {
sum[i] = sum[i - 1] + a[i];
}
memset(f, 0x7f, sizeof(f));
for (int i = 0; i <= p; i++) {
f[0][i] = 0;
}
for (int j = 1; j <= p; j++) {
int l = 1, r = 1;
q[1] = 0;
for (int i = 1; i <= m; i++) {
while (a[i] * (long long)(q[l + 1] - q[l]) >
f[q[l + 1]][j - 1] + sum[q[l + 1]] - f[q[l]][j - 1] -
sum[q[l]] &&
l < r)
l++;
f[i][j] = f[q[l]][j - 1] + a[i] * (i - q[l]) - (sum[i] - sum[q[l]]);
while ((long long)(i - q[r]) * (f[q[r]][j - 1] + sum[q[r]] -
f[q[r - 1]][j - 1] - sum[q[r - 1]]) >
(long long)(q[r] - q[r - 1]) *
(f[i][j - 1] + sum[i] - f[q[r]][j - 1] - sum[q[r]]) &&
l < r)
r--;
q[++r] = i;
}
}
printf("%lld\n", f[m][p]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long n, m, cnt = 0, mx = 0;
vector<vector<int>> a;
vector<int> d, v, at;
set<int> b;
int bfs(int x, int dd) {
v[x] = 1;
d[x] = dd;
if (b.count(x)) at[x] += 1;
for (int i = 0; i < a[x].size(); ++i)
if (v[a[x][i]] != 1) at[x] += bfs(a[x][i], dd + 1);
if (at[x]) cnt++;
if (at[x] > 0 && (mx == -1 || d[x] >= d[mx])) {
if (mx == -1 || d[x] > d[mx])
mx = x;
else if (x < mx)
mx = x;
}
return at[x];
}
void bfs1(int x, int dd) {
v[x] = 1;
d[x] = dd;
for (int i = 0; i < a[x].size(); ++i)
if (v[a[x][i]] == 0 && at[a[x][i]] > 0) bfs1(a[x][i], dd + 1);
if (d[x] > d[mx])
mx = x;
else if (d[x] == d[mx] && x < mx)
mx = x;
}
void solve() {
cin >> n >> m;
a.resize(n);
v.resize(n);
d.resize(n);
at.resize(n);
int x, y;
for (int i = 1; i < n; ++i) {
cin >> x >> y;
x--, y--;
a[x].push_back(y);
a[y].push_back(x);
}
for (int i = 0; i < m; ++i) {
cin >> x;
b.insert(x - 1);
}
fill(v.begin(), v.end(), 0);
fill(at.begin(), at.end(), 0);
fill(d.begin(), d.end(), 0);
mx = -1;
bfs(*b.begin(), 0);
unsigned long long ans = mx;
fill(v.begin(), v.end(), 0);
fill(d.begin(), d.end(), 0);
bfs1(mx, 0);
ans = min(ans, mx);
cout << ans + 1 << endl << ((cnt - d[mx] - 1) * 2 + d[mx]) << endl;
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
inline int in() {
int x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%I64d", &x);
return x;
}
struct Info {
int val, pos;
} inp[105], temp[105];
int n;
int sz;
int day;
bool nishat(Info A, Info B) { return A.val < B.val; }
int tree[N];
int out[10005][105];
int P(int fix, int group) {
memset(out, 0, sizeof out);
sz = 0;
for (int i = 1; i <= n; i++) {
if (inp[i].val > fix) {
temp[++sz] = inp[i];
temp[sz].val -= fix;
} else if (fix == 0) {
temp[++sz] = inp[i];
}
}
if (sz == 1) return 0;
if (sz == 0) return 1;
for (int i = 0; i <= 100005; i++) tree[i] = 0;
int st = 1, ed = 0;
for (int i = sz; i >= 2; i--) {
int x = temp[i].val;
for (int j = st; j <= st + x - 1; j++) {
tree[j]++;
out[j][temp[i].pos] = 1;
}
ed = max(ed, st + x - 1);
while (tree[st] >= group) st++;
if (st > ed) ed = st - 1;
}
for (int i = ed; i >= ed - temp[1].val + 1; i--) {
if (i < 1) return 0;
tree[i]++;
out[i][temp[1].pos] = 1;
}
if (fix == 0)
for (int i = ed - temp[1].val; i >= 1; i--) {
if (tree[i] < 2) {
tree[i]++;
out[i][temp[1].pos] = 1;
}
}
for (int i = 1; i <= ed; i++)
if (tree[i] < 2 || tree[i] > 5) return 0;
day = ed;
return 1;
}
int main() {
n = in();
for (int i = 1; i <= n; i++) {
inp[i].val = in();
inp[i].pos = i;
}
sort(inp + 1, inp + n + 1, nishat);
for (int i = inp[1].val; i >= 0; i--) {
if (P(i, 2)) {
printf("%d\n", i);
printf("%d\n", day);
for (int i = 1; i <= day; i++) {
for (int j = 1; j <= n; j++) {
if (out[i][j] == 0)
printf("0");
else
printf("1");
}
puts("");
}
return 0;
} else if (P(i, 3)) {
printf("%d\n", i);
printf("%d\n", day);
for (int i = 1; i <= day; i++) {
for (int j = 1; j <= n; j++) {
if (out[i][j] == 0)
printf("0");
else
printf("1");
}
puts("");
}
return 0;
} else if (P(i, 4)) {
printf("%d\n", i);
printf("%d\n", day);
for (int i = 1; i <= day; i++) {
for (int j = 1; j <= n; j++) {
if (out[i][j] == 0)
printf("0");
else
printf("1");
}
puts("");
}
return 0;
} else if (P(i, 5)) {
printf("%d\n", i);
printf("%d\n", day);
for (int i = 1; i <= day; i++) {
for (int j = 1; j <= n; j++) {
if (out[i][j] == 0)
printf("0");
else
printf("1");
}
puts("");
}
return 0;
}
}
}
| 5 |
#include <bits/stdc++.h>
char a[200005], b[200005];
int c[200005], d[200005], e[200005];
int main() {
int k, i, s = 0;
scanf("%d", &k);
scanf("%s", a);
scanf("%s", b);
for (i = k - 1; i >= 0; i--) {
c[i] = a[i] - 'a';
d[i] = b[i] - 'a';
}
memset(e, 0, sizeof(e));
for (i = k - 1; i >= 0; i--) {
e[i] += c[i] + d[i];
if (e[i] >= 26 && i != 0) {
e[i] = e[i] % 26;
e[i - 1] += 1;
}
}
for (i = 0; i < k; i++) {
if (e[i] % 2 == 0) {
printf("%c", e[i] / 2 + 'a');
} else {
printf("%c", e[i] / 2 + 'a');
e[i + 1] += 26;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int num, p, l;
} e[1100];
struct ed {
int m, num;
} us[1100];
bool cmp(edge &a, edge &b) {
if (a.p != b.p)
return a.p > b.p;
else if (a.l != b.l)
return a.l > b.l;
return a.num < b.num;
}
int min(int a, int b) { return a < b ? a : b; }
int main() {
int n, m, r, i, j, jj, now, k, sum, t, left;
bool flag[1100];
while (scanf("%d%d%d", &n, &m, &r) != EOF) {
for (i = 0; i < n; i++) {
scanf("%d%d", &e[i].p, &e[i].l);
flag[i] = false;
e[i].num = i + 1;
}
sort(e, e + n, cmp);
for (sum = 0, i = 0; i < n; i++) {
if (e[i].p != 100)
break;
else
sum += e[i].l;
}
if (sum <= r) {
printf("NO\n");
continue;
}
printf("YES\n");
k = 0, j = 0, sum = 0, left = m;
for (i = 0;; i++) {
left = left - sum + r;
if (left > m) left = m;
if (left <= 0) {
printf("%d %d\n", i, k);
for (j = 0; j < k; j++) printf("%d %d\n", us[j].m, us[j].num);
break;
}
if (j < n && m * e[j].p >= left * 100) {
now = j;
for (jj = j + 1; jj < n; jj++)
if (!flag[jj] && m * e[jj].p >= left * 100 && e[jj].l > e[now].l)
now = jj;
flag[now] = true;
us[k].m = i;
us[k++].num = e[now].num;
sum += e[now].l;
if (now == j) j++;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
string dec(string s) {
s += s;
string res = s.substr(0, 4);
for (int i = 0; i < (4); ++i)
res = (res > (s.substr(i, 4))) ? (s.substr(i, 4)) : res;
return res;
}
int main() {
int n;
string acc, t;
cin >> n;
for (int i = 0; i < (n); ++i) {
acc = "";
for (int j = 0; j < (2); ++j) {
cin >> t;
if (j) reverse((t).begin(), (t).end());
acc += t;
}
cin >> t;
m[dec(acc)]++;
}
cout << (int)(m).size() << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using std::string;
vector<pair<int, pair<int, int> > > v;
int a[5][52], n;
pair<int, int> s;
void find() {
for (int(j) = 1; (j) <= (n); ++(j)) {
for (int i = 2; i <= 3; i++) {
if (a[i][j] == 0) s = make_pair(i, j);
}
}
}
void cycle() {
int i = s.first, j = s.second, prej, prei, pre;
int N = 2 * n - 1;
while (N--) {
if (i == 2)
prej = j + 1;
else
prej = j - 1;
prei = i;
if (prei == 2 && prej == n + 1) {
prej = n;
prei = 3;
}
if (prei == 3 && prej == 0) {
prej = 1;
prei = 2;
}
pre = a[prei][prej];
a[i][j] = pre;
if (pre != 0) v.push_back(make_pair(pre, make_pair(i, j)));
if (i == 2) {
j += 1;
if (j == n + 1) {
j = n;
i = 3;
}
} else {
j -= 1;
if (j == 0) {
i = 2;
j = 1;
}
}
}
if (s.first == 2) {
s.second = s.second - 1;
if (s.second == 0) {
s.first = 3;
s.second = 1;
}
} else {
s.second = s.second + 1;
if (s.second == n + 1) {
s.second = n;
s.first = 2;
}
}
a[s.first][s.second] = 0;
}
int main() {
int k;
cin >> n >> k;
s.first == 0;
for (int(i) = 1; (i) <= (4); ++(i)) {
for (int(j) = 1; (j) <= (n); ++(j)) {
cin >> a[i][j];
}
}
int cnt = 0;
while (cnt < 2 * n) {
for (int j = 1; j <= n; j++) {
if (a[2][j] == a[1][j]) {
if (a[2][j] != 0) v.push_back(make_pair(a[2][j], make_pair(1, j)));
a[2][j] = 0;
}
if (a[3][j] == a[4][j]) {
if (a[3][j] != 0) v.push_back(make_pair(a[3][j], make_pair(4, j)));
a[3][j] = 0;
}
}
if (cnt == 0) {
find();
if (s.first == 0) break;
}
cnt++;
cycle();
}
int j = 1;
for (j = 1; j <= n; j++) {
if (a[2][j] != 0 || a[3][j] != 0) break;
}
if (j > n) {
cout << v.size() << endl;
for (int(i) = 0; (i) < (v.size()); ++(i))
cout << v[i].first << " " << (v[i].second).first << " "
<< (v[i].second).second << endl;
} else
cout << -1;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt = 0;
struct nod {
long long judge, af, bf;
};
nod a[500050];
long long ans[500050];
inline bool cmp(nod x, nod y) { return x.bf < y.bf; }
int main() {
scanf("%d", &n);
register long long l, r;
for (register int i = 1; i <= n; i++) {
scanf("%lld%lld", &l, &r);
a[++cnt].judge = 1, a[cnt].bf = l;
a[++cnt].judge = -1, a[cnt].bf = r + 1;
}
sort(a + 1, a + cnt + 1, cmp);
register long long lastpos = 0, num = 0;
for (register int i = 1; i <= cnt; i++) {
ans[num] += a[i].bf - lastpos;
lastpos = a[i].bf;
num += a[i].judge;
}
for (register int i = 1; i <= n; i++) {
printf("%lld ", ans[i]);
}
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, a;
string x, z;
cin >> n >> t;
cin >> x;
for (int i = 0; i < t; i++) {
for (int j = 0; j < n - 1; j++) {
if (x[j] == 'B' && x[j + 1] == 'G') {
x[j] = 'G';
x[j + 1] = 'B';
j++;
}
}
}
cout << x;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long sum = 0, mx = -1e9, n;
cin >> n;
for (int i = 1, x; i <= n; ++i) {
cin >> x;
sum += x;
mx = max(mx, (long long)x);
}
sum -= mx;
printf("%.9f\n", (double)sum / (n - 1) + mx);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> adj[N];
int p[N], d[N], sz[N], root[N];
int n, m, k, s, t;
int find(int v) {
if (p[v] == v) return v;
return p[v] = find(p[v]);
}
bool same(int v, int u) { return find(v) == find(u); }
void unite(int u, int v) {
u = find(u);
v = find(v);
if (sz[u] > sz[v]) swap(u, v);
sz[v] += sz[u];
p[u] = v;
}
bool can(int x) {
queue<int> q;
for (int i = 1; i <= n; i++) {
sz[i] = 1;
p[i] = i;
if (root[i]) {
q.push(i);
d[i] = 0;
} else
d[i] = 1e9;
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto u : adj[v]) {
if (d[u] > d[v] + 1) {
d[u] = d[v] + 1;
p[u] = find(v);
q.push(u);
}
if (d[u] + d[v] + 1 <= x && !same(u, v)) {
unite(u, v);
}
}
}
return same(s, t);
}
int main() {
cin >> n >> m >> k;
for (int i = 0, x; i < k; i++) {
cin >> x;
root[x] = 1;
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cin >> s >> t;
root[t] = 1;
root[s] = 1;
int lo = 1, hi = n;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (!can(mid))
lo = mid + 1;
else
hi = mid;
}
if (can(lo))
cout << lo;
else
cout << -1;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
long long x[n], y[n], f1[n], f2[n], f3[n], f4[n];
for (long long i = 0; i < n; i++)
cin >> x[i] >> y[i] >> f1[i] >> f2[i] >> f3[i] >> f4[i];
long long x1 = -1e5, x2 = 1e5;
long long y1 = -1e5, y2 = 1e5;
for (long long i = 0; i < n; i++) {
if (f1[i] == 0) {
x1 = max(x1, x[i]);
}
if (f2[i] == 0) {
y2 = min(y2, y[i]);
}
if (f3[i] == 0) {
x2 = min(x2, x[i]);
}
if (f4[i] == 0) {
y1 = max(y1, y[i]);
}
}
if (x1 <= x2 && y1 <= y2) {
cout << 1 << " " << x1 << " " << y1 << endl;
} else {
cout << 0 << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e14;
long long ab(long long x) { return x > 0 ? x : -x; }
long long a[100005];
long long kn[66];
long long sum[100005];
map<long long, int> mp;
int nxt[100005];
int main() {
int n, k;
scanf("%d%d", &n, &k);
kn[0] = 1;
int cnt = 0;
for (int i = 1;; i++) {
kn[i] = kn[i - 1] * k;
if (kn[i] == 1) break;
cnt++;
if (ab(kn[i]) >= oo) break;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= cnt; j++) {
mp[sum[n] - sum[i] - kn[j]]++;
}
}
long long ans = 0, step = 0;
for (int i = n; i >= 1; i--) {
ans += mp[step];
for (int j = 0; j <= cnt; j++) {
mp[sum[n] - sum[i - 1] - kn[j]]--;
}
step += a[i];
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,ssse3,sse3,sse4,popcnt,avx,mmx,abm,tune=native")
using namespace std;
namespace debug {
void __(short x) { cout << x; }
void __(unsigned x) { cout << x; }
void __(int x) { cout << x; }
void __(long long x) { cout << x; }
void __(unsigned long long x) { cout << x; }
void __(double x) { cout << x; }
void __(long double x) { cout << x; }
void __(char x) { cout << x; }
void __(const char *x) { cout << x; }
void __(const string &x) { cout << x; }
void __(bool x) { cout << (x ? "true" : "false"); }
template <class P1, class P2>
void __(const pair<P1, P2> &x) {
__("("), __(x.first), __(", "), __(x.second), __(")");
}
template <class T>
void __(const vector<T> &x) {
__("{");
bool _ffs = 0;
for (const auto &v : x) __(_ffs ? ", " : ""), __(v), _ffs = 1;
__("}");
}
template <class T>
void __(const set<T> &x) {
__("{");
bool _ffs = 0;
for (const auto &v : x) __(_ffs ? ", " : ""), __(v), _ffs = 1;
__("}");
}
template <class T, class T2>
void __(const map<T, T2> &x) {
__("{");
bool _ffs = 0;
for (const auto &v : x)
__(_ffs ? ", " : ""), __(make_pair(v.first, v.second)), _ffs = 1;
__("}");
}
void screm() { __("\n"); }
template <class T1, class... T2>
void screm(const T1 &t1, const T2 &...t2) {
__(t1);
if (sizeof...(t2))
__(" | "), screm(t2...);
else
__("\n");
}
void pr() { __("\n"); }
template <class T1, class... T2>
void pr(const T1 &t1, const T2 &...t2) {
__(t1);
if (sizeof...(t2))
__(" "), pr(t2...);
else
__("\n");
}
} // namespace debug
using namespace debug;
const int MN = 1e6 + 6;
int N, M, i, j, x, a[MN], b[MN], sm[MN][32], cnt[32], lo, hi;
vector<int> c;
int main() {
scanf("%d%d", &N, &M);
for (int i = (1); i <= (N); i++) scanf("%d", &a[i]);
for (int i = (1); i <= (M); i++) scanf("%d", &b[i]);
sort(b + 1, b + M + 1, [](int i, int j) { return i < j; });
for (int i = (1); i <= (M); i++) {
x = b[i];
for (int j = (0); j <= (30); j++) sm[i][j] = sm[i - 1][j];
sm[i][x]++;
}
lo = 1, hi = M + 1;
while (lo < hi) {
int m = (lo + hi) / 2;
for (int j = (0); j <= (30); j++) cnt[j] = sm[m][j];
c.clear();
for (int i = (1); i <= (N); i++) c.push_back(a[i]);
int f = 0, k;
for (int j = (30); j >= (0); j--) {
for (auto &v : c) {
k = (v >> j);
v -= (min(cnt[j], k) << j);
cnt[j] -= min(cnt[j], k);
if (!cnt[j]) break;
}
if (cnt[j]) {
f = 1;
break;
}
}
if (!f)
lo = m + 1;
else
hi = m;
}
printf("%d\n", lo - 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int MAXM = 110;
map<long long, int> p;
long long a[MAXN];
long long use[MAXM];
int main() {
int n;
scanf("%d", &n);
int cnt = 0;
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
long long u, v, w;
if (k == 1) {
scanf("%I64d%I64d%I64d", &u, &v, &w);
use[0] = 0;
while (u >= 1) {
if (!p[u]) {
cnt++;
p[u] = cnt;
}
use[0]++;
use[use[0]] = u;
u /= 2;
}
int j = 1;
while (v >= 1) {
if (!p[v]) {
cnt++;
p[v] = cnt;
}
while (v < use[j]) {
j++;
}
if (v == use[j]) {
break;
}
a[p[v]] += w;
v /= 2;
}
for (int t = 1; t < j; t++) {
a[p[use[t]]] += w;
}
} else {
long long ans = 0;
scanf("%I64d%I64d", &u, &v);
use[0] = 0;
while (u >= 1) {
if (!p[u]) {
cnt++;
p[u] = cnt;
}
use[0]++;
use[use[0]] = u;
u /= 2;
}
int j = 1;
while (v >= 1) {
if (!p[v]) {
cnt++;
p[v] = cnt;
}
while (v < use[j]) {
j++;
}
if (v == use[j]) {
break;
}
ans += a[p[v]];
v /= 2;
}
for (int t = 1; t < j; t++) {
ans += a[p[use[t]]];
}
printf("%I64d\n", ans);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
void solve() {
cin >> n >> x;
int left = x - 1;
int right = n - x;
if (left >= right)
cout << (x - 1 == 0 ? 1 : x - 1) << endl;
else
cout << (x + 1 > n ? n : x + 1) << endl;
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
;
int tt;
tt = 1;
for (int i = 1; i <= tt; ++i) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long p;
cin >> p;
if (p % 2 == 0) {
cout << 2 << " " << p / 2 << "\n";
} else {
cout << (p - 1) / 2 << " " << p - 1 << "\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> nums(n);
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
sort(nums.begin(), nums.end());
int max_diff = nums[n - 1] - nums[0];
int i = 0, j = n - 1;
long long c1 = 0, c2 = 0;
while (i < n && nums[i] == nums[0]) {
i++;
c1++;
}
while (j >= 0 && nums[j] == nums[n - 1]) {
j--;
c2++;
}
if (max_diff == 0) {
cout << max_diff << " " << c1 * (c1 - 1) / 2;
} else {
cout << max_diff << " " << c1 * c2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ret(int n);
int main() {
ios_base::sync_with_stdio(0);
int hh = 0, mm = 0, i;
string s;
cin >> s;
for (i = 0; i < 2; i++) {
hh *= 10;
hh += s[i] - '0';
}
for (i = 3; i < 5; i++) {
mm *= 10;
mm += s[i] - '0';
}
while (true) {
if (mm == 59) hh = (hh + 1) % 24;
mm = (mm + 1) % 60;
if ((hh == ret(mm) && (hh != mm || hh > 9)) ||
(ret(hh) == mm && (hh != mm || hh > 9)) || (hh == 0 && mm == 0)) {
if (hh < 10)
cout << 0 << hh;
else
cout << hh;
cout << ":";
if (mm < 10)
cout << 0 << mm;
else
cout << mm;
break;
}
}
}
int ret(int n) {
int tmp = 0;
while (n != 0) {
tmp = (tmp * 10) + (n % 10);
n /= 10;
}
return tmp;
}
| 1 |
#include <bits/stdc++.h>
const int N = 3000 * 3000 * 2 + 9;
const int d[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{1, 1}, {-1, -1}, {1, -1}, {-1, 1}};
int n, m, K, Time[N], f[N], tmp[N], v1[10], v2[10];
bool disabled[3009][6009];
inline int getfa(int x) {
for (; f[x] != x; x = f[x]) tmp[++tmp[0]] = x;
for (; tmp[0]; --tmp[0]) f[tmp[tmp[0]]] = x;
return x;
}
bool check(int x, int y, int mark) {
if (disabled[x][y]) return false;
v1[0] = v2[0] = 0;
for (int i = 0; i < 8; ++i) {
int nx = x + d[i][0], ny = y + d[i][1];
if (ny <= 0) ny = m;
if (ny > m) ny = 1;
if (nx < 1 || nx > n || !disabled[nx][ny]) continue;
int fa = getfa(((nx - 1) * m + ny));
if (Time[fa] != mark) {
Time[fa] = mark;
v1[++v1[0]] = fa;
}
}
y += m / 2;
for (int i = 0; i < 8; ++i) {
int nx = x + d[i][0], ny = y + d[i][1];
if (ny <= 0) ny = m;
if (ny > m) ny = 1;
if (nx < 1 || nx > n || !disabled[nx][ny]) continue;
int fa = getfa(((nx - 1) * m + ny));
v2[++v2[0]] = fa;
}
for (int i = 1; i <= v2[0]; ++i)
if (Time[v2[i]] == mark) return false;
int now = ((x - 1) * m + y - m / 2);
for (int i = 1; i <= v1[0]; ++i) f[v1[i]] = now;
now = ((x - 1) * m + y);
for (int i = 1; i <= v2[0]; ++i) f[v2[i]] = now;
disabled[x][y] = disabled[x][y - m / 2] = true;
return true;
}
void read(int &x) {
x = 0;
char c = getchar();
for (; c > '9' || c < '0'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - '0';
}
int main() {
scanf("%d%d%d", &n, &m, &K);
if (m == 1) return puts("0");
m *= 2;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) f[((i - 1) * m + j)] = ((i - 1) * m + j);
int ans = 0;
for (int i = 1, x, y; i <= K; ++i) {
read(x);
read(y);
ans += check(x, y, i);
}
printf("%d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
srand(time(NULL));
int v;
scanf("%d", &v);
for (int i = 0; i < v; i++) {
vector<int> a(250);
int sum = 0;
for (int j = 0; j < a.size(); j++) {
scanf("%d", &a[j]);
sum += a[j];
}
double avg = sum / 250.0;
int cnt = 0;
for (int j = 0; j < a.size(); j++) {
double val = (double)a[j] / avg;
cnt += 0.5 <= val && val <= 1.5;
}
if (cnt > 250 * 0.7) {
cout << (int)avg << "\n";
} else {
cout << *max_element(a.begin(), a.end()) / 2 << "\n";
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int i, j, a[555555], b[555555], n, m, pos, p, co;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) {
m = a[i];
pos = i;
for (j = i + 1; j < n; j++) {
if (a[j] < m) {
m = a[j];
pos = j;
}
}
if (pos != i) {
co++;
b[p++] = i;
b[p++] = pos;
a[pos] = a[i];
a[i] = m;
}
}
printf("%d\n", co);
for (i = 0; i < p; i = i + 2) printf("%d %d\n", b[i], b[i + 1]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int k, next;
} e[100005 << 1];
struct trie {
int ch[2];
void init() { ch[0] = ch[1] = 0; }
} t[100005 * 10];
int n, m, a[100005], fa[100005], home[100005], cnt = -1, f[100005][260],
dep[100005];
void add(int x, int y) {
cnt++;
e[cnt].k = y;
e[cnt].next = home[x];
home[x] = cnt;
}
void insert(int x) {
int g = 0;
for (int i = 20; ~i; i--) {
if (x & (1 << i)) {
if (!t[g].ch[1]) t[g].ch[1] = ++cnt, t[cnt].init();
g = t[g].ch[1];
} else {
if (!t[g].ch[0]) t[g].ch[0] = ++cnt, t[cnt].init();
g = t[g].ch[0];
}
}
}
int query(int x) {
int g = 0, ans = 0;
for (int i = 20; ~i; i--) {
if (x & (1 << i)) {
if (t[g].ch[0])
g = t[g].ch[0], ans ^= (1 << i);
else
g = t[g].ch[1];
} else {
if (t[g].ch[1])
g = t[g].ch[1], ans ^= (1 << i);
else
g = t[g].ch[0];
}
}
return ans;
}
int pf[100005];
void dfs(int k, int F) {
fa[k] = F;
dep[k] = dep[F] + 1;
int x = k;
cnt = 0;
t[0].init();
for (int i = 0; i < 256 && x; i++) insert(a[x] ^ i), x = fa[x];
pf[k] = x;
for (int i = 0; i < 256; i++) f[k][i] = query(i * 256);
for (int i = home[k]; ~i; i = e[i].next)
if (e[i].k != F) dfs(e[i].k, k);
}
int main() {
memset(home, -1, sizeof(home));
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, 0);
dep[0] = -1e9;
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
int ans = 0, x, dis = 0, i;
for (x = v, i = 0; dep[pf[x]] >= dep[u] - 1; x = pf[x], i++, dis += 256)
ans = max(ans, f[x][i]);
for (; dep[x] >= dep[u]; x = fa[x], dis++) ans = max(ans, a[x] ^ dis);
printf("%d\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2505;
const int M = 100005;
const int MOD = 1000000007;
int n;
int a[N];
int f[M], g[M];
int inv(int x) {
int ret = 1;
for (int y = MOD - 2; y > 1; y >>= 1) {
if (y & 1) ret = 1LL * ret * x % MOD;
x = 1LL * x * x % MOD;
}
return 1LL * ret * x % MOD;
}
int main() {
scanf("%d", &n);
int m = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
m += a[i];
}
g[1] = 1LL * (m - 1) * (m - 1) % MOD * inv(m) % MOD;
f[1] = g[1];
for (int i = 2; i < M; ++i) {
g[i] = (g[i - 1] + 1LL * (1 - m) * inv(m - i + 1)) % MOD;
f[i] = (f[i - 1] + g[i]) % MOD;
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
ans += f[a[i]];
}
ans %= MOD;
if (ans < 0) ans += MOD;
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, iin, jin, maxp, max_line, cur;
int board[505][505], bear_power[505];
int main() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> board[i][j];
}
}
maxp = 0;
for (int i = 0; i < n; i++) {
maxp = 0;
cur = 0;
for (int j = 0; j < m; j++) {
if (board[i][j] == 1) {
cur++;
} else {
if (cur > maxp) {
maxp = cur;
bear_power[i] = maxp;
max_line = i;
}
cur = 0;
}
if (cur > maxp) {
maxp = cur;
bear_power[i] = maxp;
max_line = i;
}
}
}
for (int k = 0; k < q; k++) {
cin >> iin >> jin;
board[iin - 1][jin - 1] ^= 1;
maxp = 0;
cur = 0;
for (int j = 0; j < m; j++) {
if (board[iin - 1][j] == 1) {
cur++;
} else {
if (cur >= maxp) {
maxp = cur;
bear_power[iin - 1] = maxp;
}
cur = 0;
}
if (cur >= maxp) {
maxp = cur;
bear_power[iin - 1] = maxp;
}
}
maxp = 0;
for (int j = 0; j < n; j++) {
if (maxp <= bear_power[j]) {
maxp = bear_power[j];
}
}
cout << maxp << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool filled[300002];
int main() {
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
long long pos = n;
cout << 1 << " ";
for (long long i = 0; i <= n; i++) {
filled[i] = false;
}
for (long long i = 0; i < n; i++) {
long long t;
cin >> t;
filled[t] = true;
while (filled[pos] == true) {
pos--;
}
long long ans = i + 1 - (n - pos);
cout << ans + 1 << " ";
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct ppi {
long long max;
int id;
int w;
} pp1;
struct pi {
int le;
int ri;
int max;
int id;
} pp[maxn << 2];
void build(int tot, int le, int ri) {
pp[tot].le = le;
pp[tot].ri = ri;
pp[tot].max = -1000000001;
if (le == ri) return;
build(2 * tot, le, (le + ri) / 2);
build(2 * tot + 1, (le + ri) / 2 + 1, ri);
}
void merg(int tot, int p, int k, int id) {
if (pp[tot].le == pp[tot].ri) {
if (pp[tot].max < k) {
pp[tot].max = k;
pp[tot].id = id;
}
return;
}
int mid = (pp[tot].le + pp[tot].ri) / 2;
if (p <= mid) {
merg(2 * tot, p, k, id);
} else
merg(2 * tot + 1, p, k, id);
if (pp[2 * tot].max > pp[2 * tot + 1].max) {
pp[tot].max = pp[2 * tot].max;
pp[tot].id = pp[2 * tot].id;
} else {
pp[tot].max = pp[2 * tot + 1].max;
pp[tot].id = pp[2 * tot + 1].id;
}
}
ppi query(int tot, int l, int r) {
if (pp[tot].le >= l && pp[tot].ri <= r) {
pp1.max = pp[tot].max;
pp1.id = pp[tot].id;
return pp1;
}
int mid;
mid = (pp[tot].le + pp[tot].ri) / 2;
ppi pp2;
pp2.max = -1000000001;
if (l <= mid) {
pp1 = query(2 * tot, l, r);
if (pp1.max > pp2.max) {
pp2.max = pp1.max;
pp2.id = pp1.id;
}
}
if (r > mid) {
pp1 = query(2 * tot + 1, l, r);
if (pp1.max > pp2.max) {
pp2.max = pp1.max;
pp2.id = pp1.id;
}
}
return pp2;
}
struct pppi {
int l;
int r;
int c;
int id;
int ii;
} pp3[maxn], pp4[maxn], pp5[maxn << 1];
int a[maxn];
int cmp(pppi a, pppi b) {
if (a.l != b.l) return a.l < b.l;
return a.id > b.id;
}
int cmp1(pppi a, pppi b) {
if (a.r != b.r) return a.r < b.r;
return a.id < b.id;
}
int cmp2(pppi a, pppi b) {
if (a.r != b.r) return a.r < b.r;
return a.id > b.id;
}
int main() {
int i, n, m;
cin >> n >> m;
int tot = 1;
ppi pp6;
pp6.max = -10000;
for (i = 1; i <= n; i++) {
scanf("%d%d", &pp3[i].l, &pp3[i].r);
a[i] = pp3[i].r;
pp3[i].id = 1;
pp3[i].ii = i;
pp5[tot] = pp3[i];
tot++;
}
sort(a + 1, a + 1 + n);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &pp4[i].l, &pp4[i].r, &pp4[i].c);
pp4[i].id = -1;
pp4[i].ii = i;
pp5[tot] = pp4[i];
tot++;
}
tot--;
build(1, 1, n);
sort(pp5 + 1, pp5 + 1 + tot, cmp);
for (i = 1; i <= tot; i++) {
if (pp5[i].id == 1) {
int p = lower_bound(a + 1, a + 1 + n, pp5[i].r) - a;
merg(1, p, pp5[i].r, pp5[i].ii);
} else {
int p = lower_bound(a + 1, a + 1 + n, pp5[i].l) - a;
ppi pp7;
if (p >= 1 && p <= n)
pp7 = query(1, p, n);
else
pp7.max = 0;
if ((min(pp7.max, (long long)pp5[i].r) - pp5[i].l) * pp5[i].c > pp6.max) {
pp6.max = (min(pp7.max, (long long)pp5[i].r) - pp5[i].l) * pp5[i].c;
pp6.id = pp7.id;
pp6.w = pp5[i].ii;
}
}
}
for (i = 1; i <= n; i++) {
a[i] = pp3[i].l;
}
sort(a + 1, a + 1 + n);
build(1, 1, n);
sort(pp5 + 1, pp5 + tot + 1, cmp1);
for (i = tot; i >= 1; i--) {
if (pp5[i].id == 1) {
int p = lower_bound(a + 1, a + 1 + n, pp5[i].l) - a;
merg(1, p, -pp5[i].l, pp5[i].ii);
} else {
int p = lower_bound(a + 1, a + 1 + n, pp5[i].r) - a;
if (p > n) p--;
if (p >= 1 && p <= n && a[p] > pp5[i].r) p--;
ppi pp7;
if (p >= 1 && p <= n) {
pp7 = query(1, 1, p);
pp7.max = -pp7.max;
if ((pp5[i].r - max((long long)pp5[i].l, pp7.max)) * pp5[i].c >
pp6.max) {
pp6.max = (pp5[i].r - max((long long)pp5[i].l, pp7.max)) * pp5[i].c;
pp6.id = pp7.id;
pp6.w = pp5[i].ii;
}
}
}
}
sort(pp5 + 1, pp5 + 1 + n, cmp2);
build(1, 1, n);
for (i = 1; i <= tot; i++) {
if (pp5[i].id == 1) {
int p = lower_bound(a + 1, a + 1 + n, pp5[i].l) - a;
merg(1, p, pp5[i].r - pp5[i].l, pp5[i].ii);
} else {
int p = lower_bound(a + 1, a + 1 + n, pp5[i].l) - a;
if (p >= 1 && p <= n) {
ppi pp7 = query(1, p, n);
if (pp7.max * pp5[i].c > pp6.max) {
pp6.max = pp7.max * pp5[i].c;
pp6.id = pp7.id;
pp6.w = pp5[i].ii;
}
}
}
}
if (pp6.max >= 0)
cout << pp6.max << endl;
else
cout << 0 << endl;
if (pp6.max > 0) cout << pp6.id << " " << pp6.w;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, x, y, v, t, h, n, d;
h = -1;
scanf("%lf %lf", &a, &b);
scanf("%lf", &n);
while (n--) {
scanf("%lf %lf %lf", &x, &y, &v);
d = (a - x) * (a - x) + (b - y) * (b - y);
d = sqrt(d);
t = d / v;
if (h == -1)
h = t;
else if (t < h)
h = t;
else
;
}
printf("%.10lf\n", h);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acosl(-1.0);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, x, mx = -1, sum = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> x;
sum += x;
mx = max(x, mx);
}
long long ans = ceil(2.0 * sum / n);
if (ans < mx) ans = mx;
if (ans * n == 2 * sum) ans++;
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9, oo = numeric_limits<double>::infinity();
vector<double> ans;
double simplexMethodPD(vector<vector<int>> &A, vector<int> &b, vector<int> &c) {
int n = c.size(), m = b.size();
vector<vector<double>> T(m + 1, vector<double>(n + m + 1));
vector<int> base(n + m), row(m);
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n; ++i) T[j][i] = A[j][i];
T[j][n + j] = 1;
base[row[j] = n + j] = 1;
T[j][n + m] = b[j];
}
for (int i = 0; i < n; ++i) T[m][i] = c[i];
while (1) {
int p = 0, q = 0;
for (int i = 0; i < n + m; ++i)
if (T[m][i] <= T[m][p]) p = i;
for (int j = 0; j < m; ++j)
if (T[j][n + m] <= T[q][n + m]) q = j;
double t = min(T[m][p], T[q][n + m]);
if (t >= -eps) {
vector<double> x(n);
for (int i = 0; i < m; ++i)
if (row[i] < n) x[row[i]] = T[i][n + m];
ans = x;
return -T[m][n + m];
}
if (t < T[q][n + m]) {
for (int j = 0; j < m; ++j)
if (T[j][p] >= eps)
if (T[j][p] * (T[q][n + m] - t) >= T[q][p] * (T[j][n + m] - t)) q = j;
if (T[q][p] <= eps) return oo;
} else {
for (int i = 0; i < n + m + 1; ++i) T[q][i] = -T[q][i];
for (int i = 0; i < n + m; ++i)
if (T[q][i] >= eps)
if (T[q][i] * (T[m][p] - t) >= T[q][p] * (T[m][i] - t)) p = i;
if (T[q][p] <= eps) return -oo;
}
for (int i = 0; i < m + n + 1; ++i)
if (i != p) T[q][i] /= T[q][p];
T[q][p] = 1;
base[p] = 1;
base[row[q]] = 0;
row[q] = p;
for (int j = 0; j < m + 1; ++j)
if (j != q) {
double alpha = T[j][p];
for (int i = 0; i < n + m + 1; ++i) T[j][i] -= T[q][i] * alpha;
}
}
return oo;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int t;
cin >> t;
while (t--) {
vector<int> c1(3), c2(3), d(7);
for (auto &i : c1) cin >> i;
for (auto &i : c2) cin >> i;
for (auto &i : d) cin >> i;
vector<vector<int>> A;
vector<int> c(7), b;
for (int i = 2; i >= 0; --i) {
vector<int> p(7);
int s = 0;
for (int j = 7; j; --j)
if (j >> i & 1) ++p[7 - j], s += d[7 - j];
A.push_back(p);
b.push_back(c1[2 - i]);
for (auto &i : p) i *= -1;
A.push_back(p);
b.push_back(c2[2 - i] - s);
}
for (int j = 0; j < 7; ++j) {
vector<int> p(7);
p[j] = 1;
A.push_back(p);
b.push_back(d[j]);
}
ans.clear();
simplexMethodPD(A, b, c);
if (!ans.empty()) {
vector<int> tf(7);
for (int i = 0; i < 7; ++i) tf[i] = ans[i];
bool ok2 = false;
for (int m = 0; m < 1 << 7; ++m) {
auto f = tf;
for (int j = 0; j < 7; ++j) f[j] += m >> j & 1;
bool ok = true;
for (auto &i : A) {
int x = 0;
for (int j = 0; j < 7; ++j) x += i[j] * f[j];
ok &= x <= b[&i - &A[0]];
}
if (ok) {
for (auto &i : f) cout << i << " \n"[&i == &f.back()];
ok2 = true;
break;
}
}
if (ok2) continue;
}
cout << "-1\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int r, c, t;
node() {}
node(int _r, int _c, int _t) {
r = _r;
c = _c;
t = _t;
}
} cur;
struct flow_graph {
int MAX_V, E, s, t, head, tail;
int *cap, *to, *next, *last, *dist, *q, *now;
flow_graph() {}
flow_graph(int V, int MAX_E) {
MAX_V = V;
E = 0;
cap = new int[2 * MAX_E], to = new int[2 * MAX_E],
next = new int[2 * MAX_E];
last = new int[MAX_V], q = new int[MAX_V];
dist = new int[MAX_V], now = new int[MAX_V];
fill(last, last + MAX_V, -1);
}
void add_edge(int u, int v, int uv) {
if (uv > 0) {
to[E] = v, cap[E] = uv, next[E] = last[u];
last[u] = E++;
to[E] = u, cap[E] = 0, next[E] = last[v];
last[v] = E++;
}
}
bool bfs() {
fill(dist, dist + MAX_V, -1);
head = tail = 0;
q[tail] = t;
++tail;
dist[t] = 0;
while (head < tail) {
int v = q[head];
++head;
for (int e = last[v]; e != -1; e = next[e]) {
if (cap[e ^ 1] > 0 && dist[to[e]] == -1) {
q[tail] = to[e];
++tail;
dist[to[e]] = dist[v] + 1;
}
}
}
return dist[s] != -1;
}
int dfs(int v, int f) {
if (v == t) return f;
for (int &e = now[v]; e != -1; e = next[e]) {
if (cap[e] > 0 && dist[to[e]] == dist[v] - 1) {
int ret = dfs(to[e], min(f, cap[e]));
if (ret > 0) {
cap[e] -= ret;
cap[e ^ 1] += ret;
return ret;
}
}
}
return 0;
}
int max_flow(int source, int sink) {
s = source;
t = sink;
int f = 0, df;
while (bfs()) {
for (int i = 0; i < MAX_V; ++i) now[i] = last[i];
while (true) {
df = dfs(s, INT_MAX);
if (df == 0) break;
f += df;
}
}
return f;
}
} G(2 + 10 * 10 * 62, 10 * 10 * (4 * 60 + 6));
int main() {
int n, t;
scanf("%d %d", &n, &t);
char M1[n][n], M2[n][n];
for (int i = 0; i < n; ++i) scanf("%s", M1[i]);
for (int i = 0; i < n; ++i) scanf("%s", M2[i]);
int sr = 0, sc = 0;
int dist[n][n];
memset(dist, -1, sizeof(dist));
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (M1[i][j] == 'Z') sr = i, sc = j;
int dr[] = {-1, 1, 0, 0};
int dc[] = {0, 0, -1, 1};
int r2, c2;
queue<node> Q;
Q.push(node(sr, sc, 0));
dist[sr][sc] = 0;
while (!Q.empty()) {
cur = Q.front();
Q.pop();
for (int i = 0; i < 4; ++i) {
r2 = cur.r + dr[i];
c2 = cur.c + dc[i];
if (r2 >= 0 && r2 < n && c2 >= 0 && c2 < n && dist[r2][c2] == -1 &&
M1[r2][c2] != 'Y' && M1[r2][c2] != 'Z') {
dist[r2][c2] = dist[cur.r][cur.c] + 1;
Q.push(node(r2, c2, cur.t + 1));
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (M1[i][j] >= '0' && M1[i][j] <= '9') {
G.add_edge(0, 1 + i * n + j, M1[i][j] - '0');
G.add_edge(1 + (t + 1) * n * n + i * n + j, 1 + (t + 2) * n * n,
M2[i][j] - '0');
}
}
}
for (int i = 0; i <= t; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
if ((dist[j][k] == -1 || dist[j][k] >= i) && M1[j][k] >= '0' &&
M1[j][k] <= '9') {
G.add_edge(1 + i * n * n + j * n + k, 1 + (t + 1) * n * n + j * n + k,
M2[j][k] - '0');
if (i < t && (dist[j][k] == -1 || dist[j][k] > i)) {
for (int d = 0; d < 4; ++d) {
r2 = j + dr[d];
c2 = k + dc[d];
if (r2 >= 0 && r2 < n && c2 >= 0 && c2 < n && M1[r2][c2] >= '0' &&
M1[r2][c2] <= '9' &&
(dist[r2][c2] == -1 || dist[r2][c2] >= i + 1))
G.add_edge(1 + i * n * n + j * n + k,
1 + (i + 1) * n * n + r2 * n + c2, 900);
}
}
}
}
}
}
printf("%d\n", G.max_flow(0, 1 + n * n * (t + 2)));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
int p[N];
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
long long qmi(long long a, int k) {
long long res = 1;
while (k) {
if (k & 1) res = res * a;
k >>= 1;
a = a * a;
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) p[i] = i;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
a = find(a), b = find(b);
if (a != b) p[a] = b;
}
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += p[i] == i;
cout << qmi(2, n - cnt) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, M = 2e5 + 10;
const long long inf = 1e15;
int n, m, s, t, vis[N], mark[N];
char ch[N];
long long x, dis[N];
char flag[N];
struct node {
int nex, to;
long long val;
} Edge[M << 2];
struct Node {
int dis, pos;
Node(int a = 0, int b = 0) : dis(a), pos(b) {}
friend bool operator<(const Node &a, const Node &b) { return a.dis > b.dis; }
};
int head[N], tot;
inline void init() {
tot = 0;
for (int i = 1; i <= n; ++i) {
head[i] = -1;
vis[i] = 0;
}
}
inline void add(int from, int to, long long val) {
Edge[++tot].to = to;
Edge[tot].val = val;
Edge[tot].nex = head[from];
head[from] = tot;
}
bool check(int u, int v) {
if (flag[u] == 'L' && flag[v] == 'R') return true;
if (flag[u] == 'R' && flag[v] == 'L') return true;
return false;
}
void Dijkstra(int s) {
priority_queue<Node> q;
for (int i = 1; i <= n; ++i) dis[i] = (i == s) ? 0 : inf;
q.push(Node(0, s));
while (!q.empty()) {
int pos = q.top().pos;
q.pop();
if (vis[pos]) continue;
vis[pos] = 1;
for (int i = head[pos]; i != -1; i = Edge[i].nex) {
if (dis[pos] + Edge[i].val < dis[Edge[i].to] && check(pos, Edge[i].to)) {
dis[Edge[i].to] = dis[pos] + Edge[i].val + x;
q.push(Node(dis[Edge[i].to], Edge[i].to));
} else if (dis[pos] + Edge[i].val < dis[Edge[i].to]) {
dis[Edge[i].to] = dis[pos] + Edge[i].val;
q.push(Node(dis[Edge[i].to], Edge[i].to));
}
}
}
}
int main() {
int _;
scanf("%d", &_);
while (_--) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (d > min(a, b) || c + d > a + b)
printf("NO\n");
else
printf("YES\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int s(long long int b, long long int a) {
long long int x = 0;
long long int y;
do {
y = b;
while (b != 0) {
if (b % 10 == 0) x += 6;
if (b % 10 == 1) x += 2;
if (b % 10 == 2) x += 5;
if (b % 10 == 3) x += 5;
if (b % 10 == 4) x += 4;
if (b % 10 == 5) x += 5;
if (b % 10 == 6) x += 6;
if (b % 10 == 7) x += 3;
if (b % 10 == 8) x += 7;
if (b % 10 == 9) x += 6;
b /= 10;
}
b = y;
b--;
} while (b >= a);
return x;
}
int main() {
long long int a, b;
cin >> a >> b;
cout << s(b, a);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1005 * 1005;
const int mod = 998244353;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
int n, m, r, c;
long long sumx[maxn], sumy[maxn], sumx2[maxn], sumy2[maxn];
long long dp[maxn], sumdp[maxn];
struct node {
int x, y;
long long key;
} qu[maxn];
int cmp(node a, node b) { return a.key < b.key; }
long long expmod(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b = b >> 1;
}
return ret;
}
int main() {
scanf("%d %d", &n, &m);
int num = 0;
for (int i = 1; i <= n; i++)
for (int j = 1, x; j <= m; j++) scanf("%lld", &x), qu[++num] = {i, j, x};
scanf("%d %d", &r, &c);
sort(qu + 1, qu + num + 1, cmp);
for (int i = 1; i <= num; i++) {
sumx[i] = (sumx[i - 1] + qu[i].x) % mod;
sumy[i] = (sumy[i - 1] + qu[i].y) % mod;
sumx2[i] = (sumx2[i - 1] + qu[i].x * qu[i].x) % mod;
sumy2[i] = (sumy2[i - 1] + qu[i].y * qu[i].y) % mod;
}
dp[0] = 0, dp[1] = 0;
int idx = 1;
for (int i = 2; i <= num; i++) {
if (qu[i].x == r && qu[i].y == c) idx = i;
int temp = lower_bound(qu + 1, qu + 1 + num, qu[i], cmp) - qu - 1;
if (temp == 0) continue;
long long cnt =
(sumdp[temp] % mod +
1LL * temp * (qu[i].x * qu[i].x + qu[i].y * qu[i].y) % mod +
(sumx2[temp] + sumy2[temp]) % mod - 2 * qu[i].x * sumx[temp] % mod -
2 * qu[i].y * sumy[temp] % mod + mod) %
mod;
dp[i] = cnt * expmod(temp, mod - 2) % mod;
sumdp[i] = (sumdp[i - 1] + dp[i]) % mod;
}
printf("%lld\n", dp[idx]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int data[4 * N], n, ans;
map<int, int> com;
vector<int> all;
pair<int, pair<int, int> > person[N];
bool fac(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return a.second.first < b.second.first;
}
void add(int node, int st, int en, int p, int val) {
data[node] = max(data[node], val);
if (en - st < 2) return;
int mid = (st + en) / 2;
if (p < mid)
add(node * 2 + 0, st, mid, p, val);
else
add(node * 2 + 1, mid, en, p, val);
data[node] = max(data[node * 2], data[node * 2 + 1]);
}
int get(int node, int st, int en, int l, int r) {
if (en <= l or r <= st) return 0;
if (l <= st and en <= r) return data[node];
int mid = (st + en) / 2;
return max(get(node * 2 + 0, st, mid, l, r),
get(node * 2 + 1, mid, en, l, r));
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) scanf("%d", &(person[i].first));
for (int i = 0; i < n; ++i) scanf("%d", &(person[i].second.first));
for (int i = 0; i < n; ++i) scanf("%d", &(person[i].second.second));
sort(person, person + n, fac);
int now = 1;
com[person[0].second.first] = now;
for (int i = 1; i < n; ++i)
if (person[i].second.first != person[i - 1].second.first)
com[person[i].second.first] = ++now;
for (int i = 0; i < n; ++i)
person[i].second.first = com[person[i].second.first];
sort(person, person + n);
int help;
for (int i = n - 1; i > -1; --i) {
help = get(1, 0, N, person[i].second.first + 1, N);
if (help > person[i].second.second) ans++;
if (i == 0) break;
if (person[i].first == person[i - 1].first) continue;
add(1, 0, N, person[i].second.first, person[i].second.second);
for (int j = i + 1; j < n; ++j) {
if (person[j].first != person[j - 1].first) break;
add(1, 0, N, person[j].second.first, person[j].second.second);
}
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long big = 2e9 + 5;
const long long md = 1e9 + 7;
const long long steps[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
struct fenw {
private:
vector<int> a;
int n;
public:
void build(int N) {
n = N;
a.resize(n);
for (int i = 0; i < n; i++) a[i] = 0;
}
void baff(int x, int c) {
for (; x < n; x = (x | (x - 1)) + 1) a[x] = max(a[x], c);
}
int ask(int x) {
int res = 0;
for (; x > 0; x &= x - 1) res = max(res, a[x]);
return res;
}
};
void solve();
int main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
long long q;
cin >> q;
for (; q > 0; q--) {
solve();
}
return 0;
}
fenw tree;
int n;
int l[1000000];
int r[1000000];
int a[1000000];
vector<int> q;
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
l[i] = -1;
r[i] = -1;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
if (l[a[i]] == -1) l[a[i]] = i + 4;
r[a[i]] = max(r[a[i]], i + 4);
}
int res = 0, ans = 0;
q.clear();
for (int i = 1; i <= n; i++) {
if (l[i] == -1) continue;
res++;
q.push_back(i);
}
bool bad = false;
for (int i = 1; i < n; i++) {
if (a[i] >= a[i - 1]) continue;
bad = true;
}
if (!bad) {
cout << 0 << endl;
return;
}
int L = 0, R = 0;
while (R < res) {
R++;
while (R < res && l[q[R]] > r[q[R - 1]]) R++;
ans = max(ans, R - L);
L = R;
}
cout << res - ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a;
scanf("%lld", &a);
printf("%lld 2\n1 2", 2 * a - 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
using ll = long long;
const int N = 2e5 + 5;
int n, pos[N], BIT[N];
ll res = 0;
vector<ii> pts;
void add(int p) {
for (; p <= n; p += p & -p) ++BIT[p];
}
int sum(int p) {
int res = 0;
for (; p; p -= p & -p) res += BIT[p];
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
pts.emplace_back(x, y);
pos[i] = i;
}
sort(pos, pos + n,
[](const int &a, const int &b) { return pts[a].first < pts[b].first; });
int pre = INT_MAX, cnt = 0;
for (int i = 0; i < n; ++i) {
if (pts[pos[i]].first != pre) ++cnt;
pre = pts[pos[i]].first;
pts[pos[i]].first = cnt;
}
sort(pts.begin(), pts.end(), [](const ii &a, const ii &b) {
return (a.second > b.second || (a.second == b.second && a.first < b.first));
});
int k = 0;
while (k < (int)pts.size()) {
int cury = pts[k].second;
vector<int> A;
A.push_back(0);
while (k < (int)pts.size() && pts[k].second == cury) {
A.push_back(pts[k].first);
if (sum(pts[k].first) - sum(pts[k].first - 1) == 0) add(pts[k].first);
++k;
}
for (int i = 1; i < (int)A.size(); ++i)
res += 1LL * (sum(A[i]) - sum(A[i - 1])) * (sum(cnt) - sum(A[i] - 1));
}
cout << res;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5) + 5;
int ans = int(2e9), arr[N], qu[N], n;
void add(int v, int cnt) {
if (v >= N) {
return;
}
qu[v]++;
arr[v] += cnt;
add(2 * v, ++cnt);
}
void solve() {
int y;
scanf("%d", &y);
qu[y]++;
add(2 * y, 1);
int cnt = 0;
while (y / 2) {
if (y % 2) {
y /= 2;
++cnt;
qu[y]++;
arr[y] += cnt;
add(y * 2, cnt + 1);
} else {
y /= 2;
++cnt;
qu[y]++;
arr[y] += cnt;
}
}
}
int main(int argc, char *argv[]) {
memset(arr, 0, sizeof(arr));
memset(qu, 0, sizeof(qu));
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
solve();
}
for (int i = 0; i < N; ++i) {
if (qu[i] == n) {
ans = min(ans, arr[i]);
}
}
printf("%d", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long get() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const long long N = 3e5 + 5, P = 998244353;
long long n, m, k, pre[N], suf[N], f[N], a[N], ban[N], cnt[N], w[N], v[N], tot;
signed main() {
n = get(), m = get(), k = get();
for (long long t = 1; t <= n; t++) {
long long len = get();
for (long long i = 1; i <= len; i++) a[i] = get();
long long flag = 1;
for (long long i = 2; i <= len; i++) {
if (pre[a[i]] && pre[a[i]] != a[i - 1]) {
flag = 0;
continue;
}
if (suf[a[i - 1]] && suf[a[i - 1]] != a[i]) {
flag = 0;
continue;
}
pre[a[i]] = a[i - 1], suf[a[i - 1]] = a[i];
}
if (!flag)
for (long long i = 1; i <= len; i++) ban[a[i]] = 1;
}
for (long long i = 1; i <= k; i++) {
if (pre[i]) continue;
long long flag = 0;
for (long long now = i; now; now = suf[now]) flag |= ban[now];
if (!flag) {
long long len = 0;
for (long long now = i; now; now = suf[now]) ++len;
cnt[len]++;
}
}
for (long long i = 1; i <= k; i++)
if (cnt[i]) ++tot, w[tot] = i, v[tot] = cnt[i];
f[0] = 1;
for (long long i = 0; i <= m; i++)
for (long long j = 1; j <= tot; j++)
if (w[j] <= i) f[i] = (f[i] + v[j] * f[i - w[j]] % P) % P;
printf("%lld\n", f[m]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, num[100005];
int top, to[100005];
int sum[100005][500];
map<int, int> mp;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &num[i]);
mp[num[i]]++;
}
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++)
if (it->first <= it->second) to[top++] = it->first;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < top; ++j) sum[i][j] = sum[i - 1][j] + (num[i] == to[j]);
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
int ans = 0;
for (int j = 0; j < top; j++) ans += (sum[r][j] - sum[l - 1][j]) == to[j];
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i = 0;
int a[1001] = {0}, freq[1001] = {0};
for (i = 0; i < 6; i++) {
scanf("%d", &a[i]);
freq[a[i]]++;
}
int legs = 0, num = 0;
for (i = 0; i <= 11; i++)
if (freq[i] >= 4) {
legs = freq[i];
num = i;
}
if (legs < 4) {
printf("Alien\n");
return 0;
}
if (legs == 6) {
printf("Elephant\n");
return 0;
}
for (i = 0; i <= 11; i++)
if (freq[i] == 2) {
printf("Elephant\n");
return 0;
}
printf("Bear\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
int k, n, a[maxn], f[maxn];
bool vis[maxn];
int main() {
scanf("%d %d", &n, &k);
int temp, cnt = 0;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < k; i++) {
scanf("%d", &temp);
if (!vis[temp]) {
a[++cnt] = temp;
vis[temp] = 1;
}
}
memset(f, -1, sizeof(f));
queue<int> q;
q.push(1000);
f[1000] = 0;
while (!q.empty()) {
int from = q.front();
q.pop();
for (int i = 1; i <= cnt; i++) {
int to = from + a[i] - n;
if (to == 1000) {
printf("%d\n", f[from] + 1);
return 0;
}
if (to >= 0 && to <= maxn && f[to] == -1) {
f[to] = f[from] + 1;
q.push(to);
}
}
}
printf("-1\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long fastpowMOD(long long a, long long p, long long MOD) {
if (p == 0) return 1;
long long z = fastpowMOD(a, p / 2, MOD);
z = (z * z) % MOD;
if (p % 2) z = (z * a) % MOD;
return z;
}
bool seive[100005];
void SieveOfEratosthenes(long long n) {
memset(seive, true, sizeof(seive));
for (long long p = 2; p * p <= n; p++)
if (seive[p] == true)
for (long long i = p * p; i <= n; i += p) seive[i] = false;
}
long long root(long long Arr[], long long i) {
while (Arr[i] != i) {
Arr[i] = Arr[Arr[i]];
i = Arr[i];
}
return i;
}
void weighted(long long Arr[], long long size[], long long A, long long B) {
long long root_A = root(Arr, A);
long long root_B = root(Arr, B);
if (size[root_A] < size[root_B]) {
Arr[root_A] = Arr[root_B];
size[root_B] += size[root_A];
} else {
Arr[root_B] = Arr[root_A];
size[root_A] += size[root_B];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, q;
cin >> n >> q;
long long a[n];
map<long long, long long> m;
long long ans = 0;
map<long long, long long> cnt;
for (long long i = 0; i < n; i++) {
cin >> a[i];
m[a[i]] = i;
cnt[a[i]]++;
}
for (long long i = 0; i < n;) {
long long j = m[a[i]];
long long csum = 0;
for (long long k = i; k <= j; k++) {
csum = max(csum, cnt[a[k]]);
j = max(j, m[a[k]]);
}
long long len = j - i + 1;
ans += (len - csum);
i = j + 1;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
for (int& x : a) cin >> x;
vector<pair<int, int>> b(n);
for (int i = 0; i < n; i++) {
cin >> b[i].first;
b[i].second = i;
}
sort(a.begin(), a.end());
sort(b.rbegin(), b.rend());
vector<int> c(n);
for (int i = 0; i < n; i++) {
c[b[i].second] = a[i];
}
for (int x : c) cout << x << ' ';
cout << '\n';
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.