solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int pos_mn = 1000;
int neg_mx = -1000;
int pos = 0;
int neg = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < 0) {
++neg;
neg_mx = max(neg_mx, a[i]);
} else if (a[i] > 0) {
++pos;
pos_mn = min(pos_mn, a[i]);
}
}
int need = n / 2;
if (n & 1) ++need;
if (pos < need && neg < need) {
cout << "0" << endl;
return 0;
}
if (pos >= need)
cout << pos_mn;
else
cout << neg_mx;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int k = (n + 1) / 2;
vector<long long> A(k);
for (int i = 0; i < k; ++i) scanf("%lld", &A[i]);
long long x;
scanf("%lld", &x);
A.resize(n, x);
for (int i = k; i < n; ++i) A[i] = x;
partial_sum(begin(A), end(A), begin(A));
stack<int> S;
S.push(k - 1);
long long min_sum = A[k - 1];
for (int i = k; i < n; ++i) {
if (A[i] - A[i - k] < min_sum) {
min_sum = A[i] - A[i - k];
S.push(i);
}
}
int res;
if (min_sum > 0) {
res = k;
} else {
res = -1;
for (int i = k + 1; i <= n; ++i) {
if (S.top() == n - i + k) {
S.pop();
min_sum = (S.top() >= k ? A[S.top()] - A[S.top() - k] : A[k - 1]);
}
if (min_sum + x * (i - k) > 0) {
res = i;
break;
}
}
}
printf("%d\n", res);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long c[maxn], ans[maxn];
vector<int> v, xi, yi;
int lowbit(int x) { return x & -x; }
int getid(int x) { return lower_bound(v.begin(), v.end(), x) - v.begin() + 1; }
struct node {
int x, y;
node(int _x = 0, int _y = 0) { x = _x, y = _y; }
bool operator<(const node &n1) const {
return y < n1.y || (y == n1.y && x < n1.x);
}
};
vector<node> info;
void add(int x, int v, int mx) {
while (x < mx) c[x] = (c[x] + v) % 1000000007, x += lowbit(x);
}
long long sum(int x) {
long long res = 0;
while (x) res = (res + c[x]) % 1000000007, x -= lowbit(x);
return res;
}
int main() {
int n, m, s, t;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &s, &t);
v.push_back(s);
v.push_back(t);
info.push_back(node(s, t));
}
sort(v.begin(), v.end());
if (!v.size() || v[0] != 0) {
printf("0\n");
return 0;
}
sort(info.begin(), info.end());
ans[1] = 1;
v.erase(unique(v.begin(), v.end()), v.end());
for (int i = 0; i < m; i++) {
s = getid(info[i].x);
t = getid(info[i].y);
long long dt =
((sum(t - 1) - sum(s - 1)) % 1000000007 + 1000000007 + (s == 1)) %
1000000007;
add(t, dt, v.size() + 1);
ans[t] = (ans[t] + dt) % 1000000007;
}
printf("%d\n", v[v.size() - 1] == n ? ans[v.size()] : 0);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 200005;
int n;
string s;
set<int> v1, v2;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'D') {
v1.insert(i);
} else {
v2.insert(i);
}
}
int pos = 0;
set<int>::iterator it;
while (v1.size() && v2.size()) {
pos %= n;
if (s[pos] == 'D') {
it = v2.upper_bound(pos);
if (it == v2.end()) {
it = v2.begin();
}
v2.erase(*it);
}
if (s[pos] == 'R') {
it = v1.upper_bound(pos);
if (it == v1.end()) {
it = v1.begin();
}
v1.erase(*it);
}
int mn = n;
it = v2.upper_bound(pos);
if (it != v2.end()) {
mn = min(mn, *it);
}
it = v1.upper_bound(pos);
if (it != v1.end()) {
mn = min(mn, *it);
}
if (mn == n) {
if (v2.size() != 0) {
mn = min(mn, *v2.begin());
}
if (v1.size() != 0) {
mn = min(mn, *v1.begin());
}
}
pos = mn;
}
if (v1.size() != 0) {
printf("D");
} else {
printf("R");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int cap = int(1e5) + 1;
vector<int> graph[cap];
vector<int> cnt(cap);
void dfs(int i, int h) {
cnt[h] ^= 1;
for (int j : graph[i]) dfs(j, h + 1);
}
int main() {
int n;
cin >> n;
int p;
for (int i = 2; i <= n; ++i) {
cin >> p;
graph[p].push_back(i);
}
dfs(1, 0);
int ans = 0;
for (int i = 0; i < n; ++i) ans += cnt[i];
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, t, i, r;
scanf("%d%d", &n, &t);
if (n == 1 && t > 9) {
printf("-1\n");
} else {
printf("%d", t);
r = n - 1;
if (t < 10) {
for (i = 1; i <= r; i++) {
printf("0");
}
} else {
for (i = 1; i < r; i++) {
printf("0");
}
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int viz[2001];
int v[2001], b[2001];
int poz[2001], pozaux[2001];
int n;
void interclasare(int st, int dr, int mijloc) {
int i = st, j = mijloc + 1, k = 0;
while (i <= mijloc && j <= dr) {
if (v[i] < v[j]) {
++k;
b[k] = v[i];
pozaux[k] = poz[i];
++i;
} else {
++k;
b[k] = v[j];
pozaux[k] = poz[j];
++j;
}
}
for (int k1 = i; k1 <= mijloc; ++k1) {
++k;
b[k] = v[k1];
pozaux[k] = poz[k1];
}
for (int k1 = j; k1 <= dr; ++k1) {
++k;
b[k] = v[k1];
pozaux[k] = poz[k1];
}
k = 0;
for (i = st; i <= dr; ++i) {
++k;
v[i] = b[k];
poz[i] = pozaux[k];
}
}
void sort(int st, int dr) {
if (dr - st <= 1) {
if (v[st] > v[dr]) {
int aux = v[st];
v[st] = v[dr];
v[dr] = aux;
aux = poz[st];
poz[st] = poz[dr];
poz[dr] = aux;
}
} else {
int mijloc = (st + dr) / 2;
sort(st, mijloc);
sort(mijloc + 1, dr);
interclasare(st, dr, mijloc);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
++viz[v[i]];
poz[i] = i;
}
int nr = 0;
for (int i = 1; i <= 2000; ++i) {
if (viz[i] > 1) nr += viz[i];
}
if (nr < 3)
cout << "NO";
else {
cout << "YES\n";
sort(1, n);
for (int i = 1; i <= n; ++i) {
cout << poz[i] << " ";
}
cout << "\n";
int i = 1;
int nr = 0;
while (i < n && v[i] != v[i + 1]) {
++nr;
pozaux[nr] = poz[i];
++i;
}
++nr;
pozaux[nr] = poz[i + 1];
++nr;
pozaux[nr] = poz[i];
i += 2;
for (int j = i; j <= n; ++j) {
++nr;
pozaux[nr] = poz[j];
}
for (int j = 1; j <= n; ++j) cout << pozaux[j] << " ";
cout << "\n";
nr = 0;
i = n;
while (i > 1 && v[i] != v[i - 1]) {
++nr;
pozaux[nr] = poz[i];
--i;
}
++nr;
pozaux[nr] = poz[i - 1];
++nr;
pozaux[nr] = poz[i];
i -= 2;
for (int j = i; j >= 1; --j) {
++nr;
pozaux[nr] = poz[j];
}
for (int j = nr; j >= 1; --j) cout << pozaux[j] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, INF = 1e18;
vector<long long> fac(2e3 + 10), facInv(2e3 + 10);
vector<vector<long long> > count1(1e3 + 1);
long long power(long long a, long long b) {
if (b == 0) return 1;
long long res = power(a, b / 2);
res = (res * res) % mod;
if (b % 2) return (res * a) % mod;
return res;
}
long long modInv(long long a) { return power(a, mod - 2); }
long long nCr(long long n, long long r) {
if (r < 0 || n < r) return 0;
return (((fac[n] * facInv[r]) % mod) * facInv[n - r]) % mod;
}
long long number(long long x1, long long y1, long long x2, long long y2) {
x1 = max(x1, 1LL), y1 = max(y1, 1LL);
x2 = min(1000LL, x2), y2 = min(1000LL, y2);
if (x1 > x2 || y1 > y2) return 0;
return count1[x2][y2] - count1[x2][y1 - 1] - count1[x1 - 1][y2] +
count1[x1 - 1][y1 - 1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
fac[0] = facInv[0] = 1;
for (long long i = 1; i <= 2e3 + 2; i++) {
fac[i] = (i * fac[i - 1]) % mod;
facInv[i] = modInv(fac[i]);
}
long long n, m, r;
cin >> n >> m >> r;
vector<long long> b(n);
vector<pair<long long, long long> > a(n);
for (int i = 0; i <= 1e3; i++) count1[i].resize(1e3 + 1, 0);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second >> b[i];
count1[a[i].first][a[i].second]++;
}
for (int i = 1; i <= 1e3; i++) {
for (int j = 1; j <= 1e3; j++)
count1[i][j] = count1[i][j] + count1[i - 1][j] + count1[i][j - 1] -
count1[i - 1][j - 1];
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
long long com = number(
max(a[i].first, a[j].first) - r, max(a[i].second, a[j].second) - r,
min(a[i].first, a[j].first) + r, min(a[i].second, a[j].second) + r);
long long ways = nCr(n, m);
long long num1 = number(a[i].first - r, a[i].second - r, a[i].first + r,
a[i].second + r);
long long num2 = number(a[j].first - r, a[j].second - r, a[j].first + r,
a[j].second + r);
ways = ((ways + nCr(n - num1 - num2 + com, m) - nCr(n - num1, m) -
nCr(n - num2, m)) %
mod +
mod) %
mod;
if (i != j) ways = (2 * ways) % mod;
ans = (ans + (((ways * b[i]) % mod) * b[j]) % mod) % mod;
}
}
cout << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
queue<int> prog, math, sport;
int n, s;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> s;
if (s == 1)
prog.push(i);
else if (s == 2)
math.push(i);
else
sport.push(i);
}
int team_cnt = min(prog.size(), min(math.size(), sport.size()));
cout << team_cnt << '\n';
for (int i = 0; i < team_cnt; ++i) {
cout << prog.front() << " " << math.front() << " " << sport.front() << '\n';
prog.pop();
math.pop();
sport.pop();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e5 + 50;
pair<int, int> p[nax];
double sqar(double a) { return a * a; }
int main() {
double pi = acos(-1);
int n, x0, y0;
cin >> n >> x0 >> y0;
double br = 0, sr = 1e18;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
p[i] = {x, y};
br = max(br, sqar(x - x0) + sqar(y - y0));
sr = min(sr, sqar(x - x0) + sqar(y - y0));
}
for (int i = 0; i < n; i++) {
int j = (i + 1) % n;
double x1 = p[i].first, y1 = p[i].second;
double x2 = p[j].first, y2 = p[j].second;
double l = sqar(x1 - x2) + sqar(y1 - y2);
if (l == 0) continue;
double t = ((x0 - x1) * (x2 - x1) + (y0 - y1) * (y2 - y1)) / l;
t = max(0.0, min(1.0, t));
double x = x1 + t * (x2 - x1);
double y = y1 + t * (y2 - y1);
double dis = sqar(x0 - x) + sqar(y0 - y);
sr = min(sr, dis);
}
cout << setprecision(12);
cout << pi * br - pi * sr << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Node_a {
int p, id;
} a[100010];
struct Node_t {
int b, c, id;
bool operator<(const Node_t& x) const { return c > x.c; }
} t[100010];
int n, m, k;
int ans[100010];
bool cmp_a(Node_a x, Node_a y) { return x.p > y.p; }
bool cmp_t(Node_t x, Node_t y) { return x.b > y.b; }
bool check(int x) {
long long sum = 0;
int it = 1;
priority_queue<Node_t> q;
for (int i = 1; i <= m; i += x) {
while (it <= n && t[it].b >= a[i].p) q.push(t[it++]);
if (q.empty()) return 0;
sum += q.top().c;
for (int j = i; j <= min(i + x - 1, m); j++) ans[a[j].id] = q.top().id;
q.pop();
}
return sum <= k;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) cin >> a[i].p;
for (int i = 1; i <= n; i++) cin >> t[i].b;
for (int i = 1; i <= n; i++) cin >> t[i].c;
for (int i = 1; i <= m; i++) a[i].id = i;
for (int i = 1; i <= n; i++) t[i].id = i;
sort(a + 1, a + m + 1, cmp_a);
sort(t + 1, t + n + 1, cmp_t);
int l = 0, r = m + 1;
while (l < r) {
int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (r == m + 1)
cout << "NO";
else {
cout << "YES\n";
check(l);
for (int i = 1; i <= m; i++) cout << ans[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void SolveA() {
size_t q;
cin >> q;
for (size_t i = 0; i < q; ++i) {
size_t n;
cin >> n;
size_t res = 0;
if ((n % 2)) {
if (n < 9) {
cout << "-1\n";
continue;
}
n -= 9;
++res;
}
if (n % 4) {
if (n < 6) {
cout << "-1\n";
continue;
}
n -= 6;
++res;
}
res += (n / 4);
cout << res << "\n";
}
}
void SolveC() {
size_t n;
cin >> n;
vector<int> x(n), y(n), newX(n), newY(n);
for (size_t i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
}
vector<size_t> ind(n);
for (size_t i = 0; i < n; ++i) ind[i] = i;
make_heap(ind.begin(), ind.end(),
[&x](size_t i1, size_t i2) -> bool { return x[i1] < x[i2]; });
sort_heap(ind.begin(), ind.end(),
[&x](size_t i1, size_t i2) -> bool { return x[i1] < x[i2]; });
newX[ind[0]] = 0;
for (size_t i = 1; i < n; ++i)
newX[ind[i]] = newX[ind[i - 1]] + ((x[ind[i]] == x[ind[i - 1]]) ? 0 : 1);
for (size_t i = 0; i < n; ++i) ind[i] = i;
make_heap(ind.begin(), ind.end(),
[&y](size_t i1, size_t i2) -> bool { return y[i1] < y[i2]; });
sort_heap(ind.begin(), ind.end(),
[&y](size_t i1, size_t i2) -> bool { return y[i1] < y[i2]; });
newY[ind[0]] = 0;
for (size_t i = 1; i < n; ++i)
newY[ind[i]] = newY[ind[i - 1]] + ((y[ind[i]] == y[ind[i - 1]]) ? 0 : 1);
vector<size_t> xCnt(n, 0), xStart(n, 0), ix(n);
for (size_t i = 0; i < n; ++i) ++xCnt[newX[i]];
for (size_t i = 1; i < n; ++i) xStart[i] = xStart[i - 1] + xCnt[i - 1];
xCnt.assign(n, 0);
for (size_t i = 0; i < n; ++i) {
ix[xStart[newX[i]] + xCnt[newX[i]]] = i;
++xCnt[newX[i]];
}
vector<size_t> yCnt(n, 0), yStart(n, 0), iy(n);
for (size_t i = 0; i < n; ++i) ++yCnt[newY[i]];
for (size_t i = 1; i < n; ++i) yStart[i] = yStart[i - 1] + yCnt[i - 1];
yCnt.assign(n, 0);
for (size_t i = 0; i < n; ++i) {
iy[yStart[newY[i]] + yCnt[newY[i]]] = i;
++yCnt[newY[i]];
}
long long res = 1;
const long long mod = 1000000007;
vector<int> q;
vector<int> xmarked(n, 0), ymarked(n, 0), pmarked(n, 0);
for (size_t i = 0; i < n; ++i) {
if (!pmarked[i]) {
q.clear();
size_t distinctCoords = 0;
pmarked[i] = 1;
q.push_back(i);
for (size_t j = 0; j < q.size(); ++j) {
size_t ic = q[j];
int xc = newX[ic];
int yc = newY[ic];
if (!xmarked[xc]) {
xmarked[xc] = 1;
++distinctCoords;
for (size_t k = 0; k < xCnt[xc]; ++k) {
size_t iNeib = ix[xStart[xc] + k];
if (!pmarked[iNeib]) {
q.push_back(iNeib);
pmarked[iNeib] = 1;
}
}
}
if (!ymarked[yc]) {
ymarked[yc] = 1;
++distinctCoords;
for (size_t k = 0; k < yCnt[yc]; ++k) {
size_t iNeib = iy[yStart[yc] + k];
if (!pmarked[iNeib]) {
q.push_back(iNeib);
pmarked[iNeib] = 1;
}
}
}
}
long long curMult = 1;
for (size_t j = 0; j < distinctCoords; ++j) curMult = (curMult * 2) % mod;
if (distinctCoords == q.size() + 1) curMult = (curMult + mod - 1) % mod;
res = (res * curMult) % mod;
}
}
cout << res;
}
int main(int argc, char **argv) {
SolveC();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long int modexp(long long int a, long long int b, long long int c) {
long long int ans = 1;
a %= c;
while (b) {
if (b & 1) {
ans = (ans * a) % c;
}
a = (a * a) % c;
b >>= 1;
}
return ans;
}
const long long int L = 1e5 + 5;
int main() {
string s;
cin >> s;
long long int n = 0;
n = s[1] - 48 + 10 * (s[3] - 48) + 100 * (s[4] - 48) + 1000 * (s[2] - 48) +
10000 * (s[0] - 48);
long long int t = modexp(n, 5, 100000);
printf("%05lld\n", t);
return 0;
}
| 3 |
#include <bits/stdc++.h>
char s[1000][1010], t[1010];
int dp[1010][1001], a[1000], p[1000], f[1000], c[20], n;
bool b[1001];
int len[1000], l;
inline int cost(int i, int j, int x) {
return x || j < len[i] || j < l ? c[x] : 0;
}
inline void umax(int& m, int u) { u > m && (m = u); }
void sort(int d) {
static int b[10][1000], c[1000], l[10];
int i, j, k = 0;
for (i = 0; i < 10; i++) l[i] = 0;
for (i = 0; i < n; i++) j = s[a[i]][d] - '0', b[j][l[j]++] = i;
for (i = 9; i >= 0; i--)
for (j = 0; j < l[i]; j++) c[k++] = b[i][j];
for (i = 0; i < n; i++) p[i] = a[i];
for (i = 0; i < n; i++) a[i] = p[c[i]];
for (i = 0; i < n; i++) f[a[i]] = i;
}
int main() {
int i, j, k, m, x, sum, cnt;
scanf("%s%d", t, &n);
l = (m = strlen(t)) - 1;
std::reverse(t, t + m);
while (m <= 1001) t[m++] = '0';
for (i = 0; i < n; i++) {
scanf("%s", s[i]);
len[i] = j = strlen(s[i]);
std::reverse(s[i], s[i] + j);
while (j <= 1001) s[i][j++] = '0';
a[i] = i;
}
for (i = 0; i < 10; i++) scanf("%d", c + i);
for (i = 0; i < 10; i++) c[i + 10] = c[i];
for (i = 0; i < m; i++) {
sort(i);
for (j = 0; j <= n; j++) dp[i][j] = -1.1e9;
for (x = i == l ? 1 : 0; x < 10; x++) {
if (t[i] != '?' && t[i] != x + '0') continue;
sum = cnt = k = 0;
for (j = 0; j < n; j++) {
sum += cost(a[j], i, s[a[j]][i] - '0' + x);
if (s[a[j]][i] - '0' + x > 9)
k = j + 1, b[f[a[j]]] = true, cnt++;
else
b[f[a[j]]] = false;
}
if (!i)
umax(dp[i][k], sum);
else {
if (k == cnt)
umax(dp[i][k], sum + dp[i - 1][0]);
else
return 1;
for (j = 0; j < n; j++) {
if (s[p[j]][i] - '0' + x == 9) {
b[f[p[j]]] = true;
cnt++;
}
sum -= cost(p[j], i, s[p[j]][i] - '0' + x);
sum += cost(p[j], i, s[p[j]][i] - '0' + x + 1);
while (b[k]) k++;
if (k == cnt)
umax(dp[i][k], sum + dp[i - 1][j + 1]);
else
return 1;
}
}
}
}
printf("%d\n", dp[m - 1][0]);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long long s, a, b, c;
long long x, off;
long long ans;
while (t--) {
cin >> s >> a >> b >> c;
long long d = s / c;
x = d / a;
off = x * b;
ans = d + off;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const unsigned int M = 1e9 + 7;
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
int n, min = 111, max = 0, ans = 0, maxp, minp;
cin >> n;
vector<long long> A(n);
for (long long i = 0; i < n; i++) {
cin >> A[i];
if (A[i] > max) {
max = A[i];
maxp = i + 1;
}
if (A[i] <= min) {
min = A[i];
minp = i + 1;
}
}
ans = maxp - 1 + (n - minp);
if (minp < maxp) ans--;
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
set<long long int> s;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, ans = 0, t;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> t;
if (t < 0) v.push_back(t);
}
sort(v.begin(), v.end(), greater<int>());
int l = v.size();
if (m >= l) {
int a = accumulate(v.begin(), v.end(), 0);
cout << -a;
} else {
for (int i = l - 1; i > (l - 1) - m; i--) ans += v[i];
cout << -ans;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, c = 0, n;
cin >> n;
vector<long long int> a(n);
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (i = 0; i < n - 1;) {
if (a[i] == a[i + 1]) {
a[i] -= 1;
i = 0;
} else
i++;
}
for (i = 0; i < n; i++) {
if (a[i] > 0) c += a[i];
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
fast();
double n;
cin >> n;
vector<double> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
double sum = 0;
for (int i = 0; i < n; i++) sum += v[i] / 100.0;
double res = (sum / n) * 100.0;
cout << fixed << setprecision(12) << res << endl;
cin.ignore();
cin.get();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 410;
const int MAXE = 2020;
const int INF = (int)1e9 + 10;
struct E {
int to, co;
E(int t = 0, int c = 0) : to(t), co(c) {}
} eg[2 * MAXE];
struct Flow {
vector<int> e[MAXV];
bool used[MAXV];
int ei, v;
void init(int n) {
v = n;
ei = 0;
for (int i = 0; i < n; i++) e[i] = vector<int>();
}
void add(int a, int b, int c) {
eg[ei] = E(b, c);
e[a].push_back(ei);
ei++;
eg[ei] = E(a, 0);
e[b].push_back(ei);
ei++;
}
int d[MAXV], qu[MAXV], ql, qr;
bool BFS(int s, int t) {
memset(d, -1, v * sizeof(int));
ql = qr = 0;
qu[qr++] = s;
d[s] = 0;
while (ql < qr && d[t] == -1) {
int n = qu[ql++];
vector<int> &v = e[n];
for (int i = v.size() - 1; i >= 0; i--) {
int u = v[i];
if (d[eg[u].to] == -1 && eg[u].co > 0) {
d[eg[u].to] = d[n] + 1;
qu[qr++] = eg[u].to;
}
}
}
return d[t] != -1;
}
int ptr[MAXV];
int go(int n, int p, int t) {
if (n == t) return p;
vector<int> &u = e[n];
int temp;
for (int i = ptr[n]; i < ((int)(u).size()); i++) {
if (d[n] + 1 != d[eg[u[i]].to] || eg[u[i]].co == 0) continue;
if ((temp = go(eg[u[i]].to, min(p, eg[u[i]].co), t)) == 0) continue;
eg[u[i]].co -= temp;
eg[u[i] ^ 1].co += temp;
ptr[n] = i;
return temp;
}
ptr[n] = ((int)(u).size());
return 0;
}
void dfs(int u) {
used[u] = true;
for (int i : e[u]) {
if (!used[eg[i].to] && eg[i].co) dfs(eg[i].to);
}
}
int max_flow(int s, int t) {
int ans = 0, temp;
while (BFS(s, t)) {
for (int i = 0; i < v; i++) ptr[i] = 0;
while ((temp = go(s, INF, t)) > 0) ans += temp;
}
memset(used, 0, sizeof(used));
dfs(s);
return ans;
}
} flow;
struct Edge {
int from, to, cost;
Edge(int a, int b, int c) : from(a), to(b), cost(c) {}
};
vector<Edge> es;
int p[MAXV];
void init(int n) {
flow.init(n);
for (Edge tmp : es) {
int a = tmp.from, b = tmp.to, c = tmp.cost;
flow.add(a, b, c);
flow.add(b, a, c);
}
}
vector<int> vec;
int e[MAXV][MAXV];
void dfs(int u, int p, int n, vector<int> &V) {
V.push_back(u);
for (int v = 0; v < n; v++) {
if (e[u][v] >= 0 && v != p) {
dfs(v, u, n, V);
}
}
}
void solve(int n, vector<int> &V) {
int k = ((int)(V).size());
for (int i = 0; i < k; i++) (void)0;
(void)0;
if (k == 1) {
vec.push_back(V[0]);
return;
}
int mn = INF, a = -1, b = -1;
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
int u = V[i], v = V[j];
if (e[u][v] >= 0 && e[u][v] < mn) {
mn = e[u][v];
a = u;
b = v;
}
}
}
e[a][b] = e[b][a] = -1;
vector<int> V1, V2;
dfs(a, -1, n, V1);
dfs(b, -1, n, V2);
solve(n, V1);
solve(n, V2);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
flow.init(n);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
es.push_back(Edge(a, b, c));
}
fill(p, p + n, 0);
fill(e[0], e[n], -1);
int ans = 0;
for (int i = 1; i < n; i++) {
init(n);
int tmp = flow.max_flow(i, p[i]);
ans += tmp;
e[i][p[i]] = e[p[i]][i] = tmp;
for (int j = i + 1; j < n; j++) {
if (flow.used[j] && p[i] == p[j]) p[j] = i;
}
}
vector<int> V;
for (int i = 0; i < n; i++) V.push_back(i);
solve(n, V);
printf("%d\n", ans);
for (int i = 0; i < ((int)(vec).size()); i++)
printf("%d%c", vec[i] + 1, " \n"[i == ((int)(vec).size()) - 1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int iao_year(int n, int dig) {
int pw = 1, sum = 0;
for (int i = 0; i < dig; ++i) {
pw *= 10;
sum += pw;
}
int lwb = 1989 + sum - pw, upb = 1989 + sum;
if (n >= lwb % pw)
return lwb / pw * pw + n;
else
return upb / pw * pw + n;
}
int main() {
int t, n, dig;
char ch;
scanf("%d", &t);
getchar();
do {
for (int i = 0; i < 4; ++i) getchar();
n = 0;
dig = 0;
while ((ch = getchar()) >= '0' && ch <= '9') {
n = n * 10 + ch - '0';
++dig;
}
printf("%d\n", iao_year(n, dig));
} while (--t);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int inp[100005];
int cnt[100005];
int main() {
int n, ans, mid;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &inp[i]);
ans = 2000000000;
mid = (n / 2) + (n & 1);
for (int i = 1; i <= mid; i++) {
if (inp[i] >= i) {
cnt[inp[i] - i]++;
}
if (i != n - i + 1 && inp[n - i + 1] >= i) {
cnt[inp[n - i + 1] - i]++;
}
}
for (int i = 0; i <= 100005; i++) {
ans = min(ans, n - cnt[i]);
}
if (n == 1) ans = 0;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 10;
int a[N], b[N], ans[N];
int n, mx;
void s0() {
int s = n;
while (s % 2 == 1) s--;
int c = 0;
for (int i = s; i >= 2; i -= 2) {
int le = (i - 1) / 2, ri = n - i / 2;
c = max(c, max(a[le], a[ri]));
if (i == s && ri - le == 2) c = max(c, a[le + 1]);
ans[n - i] = c;
}
}
void s1() {
int s = n;
while (s % 2 == 0) s--;
int c = 0;
for (int i = s; i >= 3; i -= 2) {
int le = i / 2 - 1, ri = n - 2 - i / 2;
c = max(c, max(b[le], b[ri]));
ans[n - i] = c;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) mx = max(mx, a[i]);
for (int i = 0; i < n - 2; i++) b[i] = min(a[i + 1], max(a[i], a[i + 2]));
ans[n - 1] = mx;
s0();
s1();
for (int i = 0; i < n; i++) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) {
if (!a) return b;
return GCD(b % a, a);
}
bool valid(string &str, int start, int last) {
stack<char> S;
for (int i = start; i < last; i++) {
if (str[i] == '(') {
S.push('(');
} else if (str[i] == ')') {
if (S.empty()) return false;
S.pop();
}
}
if (S.empty()) return true;
return false;
}
int main() {
clock_t startTime = clock();
ios_base::sync_with_stdio(false);
string str;
cin >> str;
int n = str.size();
int c = 0;
int last = -1;
for (int i = 0; i < n; i++) {
if (str[i] == '#') {
str[i] = ')';
c++;
last = i;
}
}
if (valid(str, last + 1, n) || 1) {
int left = 0;
for (int i = 0; i < n; i++) {
if (str[i] == '(')
left++;
else
left--;
}
if (left >= 0) {
string nstr;
for (int i = 0; i < last; i++) nstr += str[i];
for (int i = 0; i < left + 1; i++) nstr += ')';
for (int i = last + 1; i < n; i++) nstr += str[i];
if (valid(nstr, 0, nstr.size())) {
for (int i = 1; i < c; i++) cout << "1\n";
cout << left + 1 << "\n";
} else {
cout << "-1\n";
}
} else {
cout << "-1\n";
}
} else {
cout << "-1\n";
}
clock_t endTime = clock();
cerr << "\nTime:" << double(endTime - startTime) / CLOCKS_PER_SEC
<< " seconds\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int p = 0, m = 1;
for (int i = 1; i < s.size(); i++) {
if (s[i] == s[i - 1])
m++;
else
m = 1;
p = max(p, m);
}
if (p >= 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T = int>
inline T readNxt() {
char c = nc();
T x = 0;
int f = 1;
for (; c > '9' || c < '0'; c = nc())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= f;
return x;
}
struct TrieNode {
struct TrieNode *zero;
struct TrieNode *one;
int cnt;
};
struct TrieNode *getNode(void) {
struct TrieNode *pNode = new TrieNode;
pNode->cnt = 0;
pNode->zero = NULL;
pNode->one = NULL;
return pNode;
}
void insert(struct TrieNode *root, bitset<31> key) {
struct TrieNode *pCrawl = root;
for (int i = key.size() - 1; i >= 0; i--) {
if (key[i]) {
if (!pCrawl->one) pCrawl->one = getNode();
pCrawl = pCrawl->one;
} else {
if (!pCrawl->zero) pCrawl->zero = getNode();
pCrawl = pCrawl->zero;
}
pCrawl->cnt += 1;
}
}
bitset<31> search(struct TrieNode *root, bitset<31> key) {
struct TrieNode *pCrawl = root;
bitset<31> tmp;
tmp.reset();
for (int i = key.size() - 1; i >= 0; i--) {
if (!key[i]) {
if (pCrawl->one && pCrawl->one->cnt)
pCrawl = pCrawl->one, tmp[i] = 1;
else
pCrawl = pCrawl->zero;
} else {
if (pCrawl->zero && pCrawl->zero->cnt)
pCrawl = pCrawl->zero;
else
pCrawl = pCrawl->one, tmp[i] = 1;
}
}
return (key ^ tmp);
}
void del(struct TrieNode *root, bitset<31> key) {
struct TrieNode *pCrawl = root;
for (int i = key.size() - 1; i >= 0; i--) {
if (key[i]) {
pCrawl = pCrawl->one;
pCrawl->cnt -= 1;
} else {
pCrawl = pCrawl->zero;
pCrawl->cnt -= 1;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie();
string s;
getline(cin, s);
stringstream ss1(s);
ss1 >> n;
long long x = 0;
struct TrieNode *root = getNode();
bitset<31> init(0);
insert(root, init);
char c;
while (n--) {
getline(cin, s);
stringstream ss(s);
ss >> c >> x;
bitset<31> b(x);
if (c == '+') {
insert(root, b);
continue;
}
if (c == '-') {
del(root, b);
continue;
}
printf("%I64d\n", (long long)search(root, b).to_ulong());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const int MN = 30;
int arr[MN];
int n, k, mid;
long long S;
long long fact[MN];
unordered_map<long long, int> mp[MN];
long long ans = 0;
void dfsL(int pl, int rem, long long val) {
if (pl == mid) {
mp[rem][val]++;
return;
}
if (arr[pl] < 20 && fact[arr[pl]] <= S && rem < k)
dfsL(pl + 1, rem + 1, val + fact[arr[pl]]);
dfsL(pl + 1, rem, val + arr[pl]);
dfsL(pl + 1, rem, val);
}
void dfsR(int pl, int rem, long long val) {
if (pl == n) {
for (int i = 0; i <= k - rem; ++i) ans += mp[i][S - val];
return;
}
if (arr[pl] < 20 && fact[arr[pl]] <= S && rem < k)
dfsR(pl + 1, rem + 1, val + fact[arr[pl]]);
dfsR(pl + 1, rem, val + arr[pl]);
dfsR(pl + 1, rem, val);
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k >> S;
for (int i = 0; i < n; ++i) cin >> arr[i];
fact[0] = 1;
for (int i = 1; i < 20; ++i) fact[i] = 1ll * i * fact[i - 1];
mid = n / 2;
dfsL(0, 0, 0);
dfsR(mid, 0, 0);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int extgcd(int a, int b, long long &x, long long &y) {
int d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
int main() {
int n;
scanf("%d", &n);
int i = 2;
int t = n;
while (t > 1 && i <= sqrt(n)) {
if (t % i == 0) {
while (t % i == 0) t /= i;
v.push_back(i);
}
i++;
}
if (t > 1) v.push_back(t);
if (v.size() == 1) {
printf("NO\n");
return 0;
}
int j;
bool f = true;
for (i = 0; i < v.size() && f; i++)
for (j = i + 1; j < v.size(); j++) {
long long p, q;
extgcd(v[i], v[j], p, q);
p *= n - 1;
q *= n - 1;
int a = v[i], b = v[j];
if (q < 0) {
swap(a, b);
swap(p, q);
}
long long t = (-p) / b + 1;
p += b * t;
q -= a * t;
if (q > 0) {
printf("YES\n2\n");
printf("%d %d\n%d %d\n", (int)p, (int)n / a, (int)q, (int)n / b);
f = false;
break;
}
}
if (f) printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, res;
cin >> n;
res = (n * (n + 1)) / 2;
cout << res % 2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char next_char(char one, char two) {
for (int i = 'a'; i <= 'z'; i++) {
if (i != one && i != two) {
return i;
}
}
return 0;
}
int main() {
string s;
cin >> s;
for (int i = 1; i < (int)s.size(); i++) {
if (s[i] == s[i - 1]) {
if (i != (int)s.size() - 1) {
s[i] = next_char(s[i - 1], s[i + 1]);
} else {
s[i] = next_char(s[i - 1], 0);
}
}
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
int res = 0, fh = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') fh = -1, ch = getchar();
while (ch <= '9' && ch >= '0') res = res * 10 + ch - '0', ch = getchar();
return res * fh;
}
int n, m, G;
int a[1000005], x[1000005], y[1000005], z[1000005], t[1000005];
inline int ra() { return (rand() << 15 ^ rand()) & (~0u >> 1); }
inline int gcd(const int &a, const int &b) { return b ? gcd(b, a % b) : a; }
void init() {
n = getint();
m = getint();
G = n;
x[0] = n;
for (int i = 1; i <= m; i++) {
x[i] = getint();
}
sort(x + 1, x + 1 + m);
for (int i = 1; i <= m; i++) G = gcd(G, x[i] - x[1]);
if (m == 1) {
printf("%d 1\n", x[1]);
exit(0);
}
if (m == n / G) {
printf("%d %d\n", x[1], G);
exit(0);
}
for (int i = 1; i <= m; i++) a[i] = x[i] / G;
}
map<int, int> cnt;
int work(int *x, int n, int m, int times = 0) {
if (times > 40) return -1;
if (m <= 50) {
cnt.clear();
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= m; j++) {
if (i != j) {
int d = (x[i] - x[j] + n) % n;
if (gcd(d, n) == 1 && ++cnt[d] == m - 1) {
return d;
}
}
}
}
return -1;
}
if (m == n - 1) return 1;
int w = x[ra() % m + 1], my = 0, mz = 0, mt = 0;
if (w + w < n) {
for (int i = 1; i <= m; i++) {
if (w + w - x[i] < 0) {
y[++my] = w + w - x[i] + n;
} else {
z[++mz] = w + w - x[i];
}
}
} else {
for (int i = 1; i <= m; i++) {
if (w + w - x[i] < n) {
y[++my] = w + w - x[i];
} else {
z[++mz] = w + w - x[i] - n;
}
}
}
for (int i = 1, j = my, k = mz; i <= m; i++) {
while (j && y[j] < x[i]) j--;
while (k && z[k] < x[i]) k--;
if ((!j || x[i] != y[j]) && (!k || x[i] != z[k])) t[++mt] = x[i];
}
if (mt > 1) {
memcpy(x, t, mt + 1 << 2);
return work(x, n, mt, times + 1);
}
return work(x, n, m, times + 1);
}
int main() {
init();
int d = work(a, n / G, m);
if (d == -1) return puts("-1"), 0;
d *= G;
int s = x[1], cf = 0;
for (int i = 1; i <= m; i++) {
if (!binary_search(x + 1, x + m + 1, (x[i] + d) % n)) {
cf++;
s = x[i];
}
}
if (cf <= 1) {
printf("%d %d\n", s, (n - d) % n);
} else
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 210;
int T, n, m;
set<int> s[M];
vector<pair<int, int> > ans;
void DFS(int x) {
while (s[x].size()) {
int p = *s[x].begin();
s[x].erase(p);
s[p].erase(x);
ans.push_back(make_pair(x, p));
DFS(p);
}
}
int main() {
scanf("%d", &T);
while (T--) {
ans.clear();
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
s[x].insert(y);
s[y].insert(x);
}
for (int i = 1; i <= n; i++)
if (s[i].size() % 2) {
s[n + 1].insert(i);
s[i].insert(n + 1);
}
printf("%d\n", n - s[n + 1].size());
for (int i = 1; i <= n; i++) DFS(i);
for (int i = 0; i < ans.size(); i++)
if (ans[i].first != n + 1 && ans[i].second != n + 1)
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int coins[50];
int arr[100010];
bool chk;
void precal() {
coins[1] = 1;
for (int i = 2; i <= 40; i++) {
coins[i] = coins[i - 1] * 3;
}
}
int main() {
precal();
long long int n, x, cnt, pos;
cin >> x;
cnt = 0;
for (int i = 39; i >= 1; i--) {
if (x % coins[i] == 0) {
cnt = (x / coins[i + 1]) + 1;
break;
}
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, an, ani, anj;
char a[510];
int s[510];
int main() {
cin >> n;
cin >> a + 1;
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + (a[i] == '(' ? 1 : -1);
if (s[n] != 0) return puts("0\n1 1"), 0;
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
swap(a[i], a[j]);
int mini = 510, ans = 0;
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + (a[i] == '(' ? 1 : -1);
for (int i = 1; i <= n; i++) {
if (s[i] < mini)
ans = 1, mini = s[i];
else if (s[i] == mini)
ans++;
}
if (ans > an) an = ans, ani = i, anj = j;
swap(a[i], a[j]);
}
}
cout << an << endl << ani << " " << anj;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long md = 1000000007;
long long fact[100005], mi[100005], expt[100005];
long long pw(long long a, long long b) {
long long c = 1, m = a;
while (b) {
if (b & 1) c = (c * m) % md;
m = (m * m) % md;
b /= 2;
}
return c;
}
long long modinv(long long n) { return pw(n, md - 2); }
inline long long add(long long a, long long b) { return (md + a + b) % md; }
inline long long subt(long long a, long long b) { return (a - b + md) % md; }
inline long long mult(long long a, long long b) { return (1ll * a * b) % md; }
long long ncr(int n, int r) {
if (!n) return 1;
return mult(fact[n], mult(mi[r], mi[n - r]));
}
void pre() {
fact[0] = 1;
for (int i = 1; i < 100003; i++) fact[i] = mult(i, fact[i - 1]);
for (int i = 0; i < 100003; i++) mi[i] = modinv(fact[i]);
}
int myceil(int a, int b) {
if (a % b)
return (a / b) + 1;
else
return a / b;
};
void solvetestcase(int tcn) {
vector<pair<int, int>> link;
vector<long long> valans;
long long n, m;
cin >> n >> m;
vector<long long> net(n, 0);
vector<int> adj[n];
for (int i = 0; i < m; i++) {
long long x, y, z;
cin >> x >> y >> z;
x--, y--;
net[x] -= z;
net[y] += z;
adj[x].push_back(y);
}
long long j = 0;
for (int i = 0; i < n; i++) {
while (net[i] < 0) {
if (net[j] <= 0)
j++;
else {
if (net[j] >= -1 * net[i]) {
valans.push_back(-1 * net[i]);
link.push_back(make_pair(i, j));
net[j] += net[i];
net[i] = 0;
break;
} else {
valans.push_back(net[j]);
link.push_back(make_pair(i, j));
net[i] += net[j];
net[j] = 0;
j++;
}
}
}
}
cout << valans.size() << '\n';
for (int i = 0; i < valans.size(); i++)
cout << link[i].first + 1 << " " << link[i].second + 1 << " " << valans[i]
<< '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
for (int T = 1; T < t + 1; T++) {
solvetestcase(T);
}
};
| 6 |
#include <bits/stdc++.h>
using namespace std;
int cnt4, cnt7, cnt47, cnt74;
int main() {
ios::sync_with_stdio(false);
cin >> cnt4 >> cnt7 >> cnt47 >> cnt74;
if (abs(cnt47 - cnt74) > 1) {
puts("-1");
return 0;
}
string ans;
if (cnt47 < cnt74) {
assert(cnt47 + 1 == cnt74);
while (cnt74--) ans += "74", cnt4--, cnt7--;
} else if (cnt47 > cnt74) {
assert(cnt47 == cnt74 + 1);
while (cnt47--) ans += "47", cnt4--, cnt7--;
} else {
assert(cnt47 == cnt74);
while (cnt47--) ans += "47", cnt4--, cnt7--;
if (cnt4 > 0)
ans.push_back('4'), cnt4--;
else {
if (cnt7 <= 0) {
puts("-1");
return 0;
}
ans = '7' + ans;
cnt7--;
}
}
if (cnt4 < 0 || cnt7 < 0) {
puts("-1");
return 0;
}
int pos4 = -1, pos7 = -1;
for (int i = 0; i < ans.size(); i++) {
if (ans[i] == '4' && pos4 == -1) pos4 = i;
if (ans[i] == '7') pos7 = i;
}
if (pos4 != -1) ans.insert(pos4, cnt4, '4');
if (pos7 != -1) ans.insert(cnt4 + pos7, cnt7, '7');
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007ll;
int m;
struct Matrix {
long long arr[105][105];
Matrix() { memset(arr, 0, sizeof arr); }
Matrix operator*(const Matrix& p) const {
Matrix res;
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
for (int k = 0; k < m; k++)
res.arr[i][j] += (arr[i][k] * p.arr[k][j]) % mod;
res.arr[i][j] %= mod;
}
return res;
}
};
Matrix BigMod(Matrix B, long long P) {
Matrix R;
for (int i = 0; i < m; i++) R.arr[i][i] = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B);
}
P /= 2;
B = (B * B);
}
return R;
}
long long cnt1[1000005];
long long cnt2[1000005];
long long cnt3[1000005];
int main() {
int n, l, x;
scanf("%d %d %d", &n, &l, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
cnt1[x % m]++;
}
Matrix mat;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
for (int j = 0; j < m; j++) mat.arr[j][(j + x) % m]++;
cnt2[i] = x;
}
for (int i = 0; i < n; i++) {
scanf("%d", &x);
x += cnt2[i];
cnt3[(x) % m]++;
}
Matrix res = BigMod(mat, l - 2);
long long ans = 0;
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++) {
long long tem = cnt1[i] * res.arr[i][j];
tem %= mod;
tem *= cnt3[(m - j) % m];
tem %= mod;
ans += tem;
ans %= mod;
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
string s, t;
cin >> s >> t;
int n = s.size();
int m = t.size();
for (int i = 0; i < n; i++) {
if (s[i] == 'C') s[i] = 'B';
}
for (int i = 0; i < m; i++) {
if (t[i] == 'C') t[i] = 'B';
}
vector<int> as(n + 1), bs(n + 1), at(m + 1), bt(m + 1);
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
as[i + 1] = as[i] + 1;
else
bs[i + 1]++;
}
for (int i = 0; i < m; i++) {
if (t[i] == 'A')
at[i + 1] = at[i] + 1;
else
bt[i + 1]++;
}
for (int i = 1; i <= n; i++) {
bs[i] += bs[i - 1];
}
for (int i = 1; i <= m; i++) {
bt[i] += bt[i - 1];
}
int q;
cin >> q;
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
c--;
d--;
int bsk = bs[b + 1] - bs[a];
int btk = bt[d + 1] - bt[c];
int ask = min(as[b + 1], b - a + 1);
int atk = min(at[d + 1], d - c + 1);
if (ask > atk && ask % 3 != atk % 3) bsk += 2;
if (bsk == 0 && btk > 0 && ask == atk)
cout << 0;
else if (ask >= atk && bsk % 2 == btk % 2 && bsk <= btk)
cout << 1;
else
cout << 0;
}
}
| 8 |
#include <bits/stdc++.h>
int DEBUG = 1;
using namespace std;
const int N = 1000 + 5;
int parent[N + N], sz[N + N];
int find_set(int v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
void make_set(int v) {
parent[v] = v;
sz[v] = 1;
}
void merge(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
parent[b] = a;
sz[a] += sz[b];
}
int n, m;
vector<int> g[N + N];
vector<int> gt[N + N];
int odeg[N + N];
char s[N][N];
int color[N + N];
int was_cycle = 0;
void dfs(int v) {
if (color[v] == 1) {
was_cycle = 1;
return;
}
color[v] = 1;
for (int to : gt[v]) {
if (color[to] != 2) {
dfs(to);
}
}
color[v] = 2;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n + m; i++) make_set(i);
bool bad = false;
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
for (int j = 0; j < m; j++) {
if (s[i][j] == '=') {
merge(i, j + n);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] != '=') {
if (find_set(i) == find_set(j + n)) bad = true;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '=') continue;
int u = i;
int v = j + n;
if (s[i][j] == '<') swap(u, v);
u = find_set(u);
v = find_set(v);
g[u].push_back(v);
gt[v].push_back(u);
odeg[u]++;
}
}
for (int v = 0; v < n + m; v++) {
if (color[v] == 0) {
dfs(v);
}
}
if (was_cycle || bad) {
printf("No\n");
return 0;
}
set<pair<int, int> > st;
for (int v = 0; v < n + m; v++) {
st.insert(make_pair(odeg[v], v));
}
map<int, int> mp;
int GI = 1;
while (!st.empty()) {
vector<int> cur;
while (!st.empty() && st.begin()->first == 0) {
cur.push_back(st.begin()->second);
st.erase(st.begin());
}
for (int v : cur) {
mp[v] = GI;
}
for (int v : cur) {
for (int nei : gt[v]) {
st.erase({odeg[nei], nei});
odeg[nei]--;
st.insert({odeg[nei], nei});
}
}
GI++;
}
printf("Yes\n");
for (int i = 0; i < n; i++) {
int val = mp[find_set(i)];
printf("%d ", val);
}
printf("\n");
for (int i = n; i < n + m; i++) {
int val = mp[find_set(i)];
printf("%d ", val);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma hdrstop
using namespace std;
string s, s1;
int a[100], b[100], c[100];
int i, j, k = 0, n, l1, l, f = 0;
bool p;
int main() {
cin >> s;
cin >> s1;
l = s.length();
l1 = s1.length();
for (i = 0; i < l1; i++) b[s1[i] - 63]++;
if (l1 > l) {
cout << 0;
return 0;
}
for (i = 0; i < l1; i++) a[s[i] - 63]++;
p = false;
for (i = 1; i <= 99; i++) {
if (a[i] > b[i]) p = true;
}
if (p == false) k++;
for (i = l1; i < l; i++) {
p = false;
a[s[i - l1] - 63]--;
a[s[i] - 63]++;
for (j = 1; j <= 99; j++) {
if (a[j] > b[j]) p = true;
}
if (p == false) k++;
}
cout << k;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double p[20], dp[1 << 20], ans[20];
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%lf", p + i);
dp[0] = 1;
for (int i = 0; i < (1 << n); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) cnt++;
if (cnt <= k) {
double rest = 0;
for (int j = 0; j < n; j++)
if (!(i & (1 << j))) rest += p[j];
for (int j = 0; j < n; j++)
if (i & (1 << j))
if (p[j] > 0) {
double here = dp[i ^ (1 << j)] * p[j] / (rest + p[j]);
ans[j] += here;
dp[i] += here;
}
}
}
for (int i = 0; i < n; i++) printf("%.10f ", ans[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long x, long long k) {
if (k == 0) return 1;
long long ans = f(x, k / 2);
ans *= ans;
if (k % 2) ans *= x;
return ans;
}
int p[205], prime[205], cnt_prime;
bool not_prime[1005];
vector<int> v;
int main() {
for (int i = 2; i <= 35; ++i)
if (!not_prime[i])
for (int j = i * i; j <= 1000; j += i) not_prime[j] = true;
for (int i = 2; i <= 1000; ++i)
if (!not_prime[i]) prime[cnt_prime++] = i;
int n;
scanf("%d", &n);
if (n == 1) {
printf("1");
return 0;
}
for (int i = 0; i < cnt_prime; ++i)
if (n % prime[i] == 0) {
while (n % prime[i] == 0)
n /= prime[i], ++p[i], v.push_back(prime[i] - 1);
if (n == 1) break;
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size() / 2; ++i) swap(v[i], v[v.size() - i - 1]);
for (int i = v.size() - 1; i >= 0; --i)
for (int j = i - 1; j >= 0; --j)
if (pow(prime[j], v[j] + 1) < prime[i]) {
v[j] = v[i] * v[j] + v[i] + v[j];
v[i] = 0;
break;
}
long long ans = 1;
;
for (int i = 0; i < v.size(); ++i) ans *= f(prime[i], v[i]);
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int v[26][200200];
int main(void) {
char s[200200], t[200200];
cin >> s >> t;
int n = strlen(s), m = strlen(t), l[200200] = {0}, r[200200] = {0};
for (int i = 0; i < n; ++i) l[i + 1] = l[i] + (s[i] == t[l[i]]);
for (int i = n; i-- > 0;) r[i] = r[i + 1] + (s[i] == t[m - 1 - r[i + 1]]);
for (int i = 0; i < m; ++i) {
for (int j = 0; j < 26; ++j) v[j][i + 1] = v[j][i];
v[t[i] - 'a'][i + 1] = i + 1;
}
char f = 1;
for (int i = 0; f && i < n; ++i)
if (v[s[i] - 'a'][l[i + 1]] + r[i] - 1 < m) f = 0;
cout << (f ? "Yes" : "No") << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int h[100010], f[100010], c[100010], dp[2][5010];
unordered_map<int, int> mp, mpp;
int main() {
cin.tie(0);
int ans = 0;
ios::sync_with_stdio(0);
mp.clear();
mpp.clear();
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
cin >> c[i];
if (!mp[c[i]]) mp[c[i]] = 0;
mp[c[i]]++;
}
for (int i = 1; i <= n; i++) {
cin >> f[i];
if (!mpp[f[i]]) mpp[f[i]] = 0;
mpp[f[i]]++;
}
for (int i = 1; i <= k; i++) cin >> h[i];
for (auto it : mpp) {
int cur = 1, pre = 0;
int i = it.first, res = 0;
int t = it.second, m = mp[i];
memset(dp, 0, sizeof(dp));
for (int j = 1; j <= t; j++) {
for (int l = 0; l <= m && l <= j * k; l++) {
for (int p = 0; p <= k && p <= l; p++)
if (l - p <= (j - 1) * k)
dp[cur][l] = max(dp[cur][l], dp[pre][l - p] + h[p]);
res = max(res, dp[cur][l]);
}
swap(cur, pre);
}
ans += res;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n1[3005], n2[3005], lk[3005], rk[3005], father[1005], n, m;
void init() {
int i;
for (i = 0; i <= n; i++) {
father[i] = i;
}
return;
}
int find(int x) { return father[x] - x ? father[x] = find(father[x]) : x; }
int merge(int x, int y) {
int a, b;
a = find(x);
b = find(y);
if (a == b) {
return 1;
} else {
father[b] = a;
return 0;
}
}
int solve(int a, int b) {
init();
for (int i = 0; i < m; i++) {
if (lk[i] > a || rk[i] < b) continue;
merge(n1[i], n2[i]);
}
if (find(1) == find(n))
return 1;
else
return 0;
}
int main() {
int i;
while (~scanf("%d%d", &n, &m)) {
set<int> ll, rl;
for (i = 0; i < m; i++) {
scanf("%d%d%d%d", &n1[i], &n2[i], &lk[i], &rk[i]);
ll.insert(lk[i]);
rl.insert(rk[i]);
}
int ltemp[3005], rtemp[3005], lnum = ll.size(), rnum = rl.size();
set<int>::iterator itl, itr;
for (itr = rl.begin(), i = 0; itr != rl.end(); itr++, i++) {
rtemp[i] = *itr;
}
for (itl = ll.begin(), i = 0; itl != ll.end(); itl++, i++) {
ltemp[i] = *itl;
}
int ans = -1;
for (i = 0; i < lnum; i++) {
int low = 0, high = rnum - 1, mid;
while (low <= high) {
mid = low + (high - low) / 2;
if (solve(ltemp[i], rtemp[mid])) {
if (ans < rtemp[mid] - ltemp[i]) {
ans = rtemp[mid] - ltemp[i];
}
low = mid + 1;
} else {
if (rtemp[mid] - ltemp[i] <= ans) break;
high = mid - 1;
}
}
}
if (~ans)
printf("%d\n", ans + 1);
else
printf("Nice work, Dima!\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct laptop {
int id;
int speed;
int ram;
int hdd;
int price;
} lap[101];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> lap[i].speed;
cin >> lap[i].ram;
cin >> lap[i].hdd;
cin >> lap[i].price;
lap[i].id = i + 1;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
if (lap[i].id != 0 && lap[i].speed < lap[j].speed &&
lap[i].ram < lap[j].ram && lap[i].hdd < lap[j].hdd) {
lap[i].id = 0;
continue;
}
}
}
int cheap = 1010;
int indx = 0;
for (int i = 0; i < n; ++i) {
if (lap[i].id) {
if (lap[i].price < cheap) {
cheap = lap[i].price;
indx = lap[i].id;
}
}
}
cout << indx << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char IN;
bool NEG;
inline void Int(int &x) {
NEG = 0;
while (!isdigit(IN = getchar()))
if (IN == '-') NEG = 1;
x = IN - '0';
while (isdigit(IN = getchar())) x = x * 10 + IN - '0';
if (NEG) x = -x;
}
inline void LL(long long &x) {
NEG = 0;
while (!isdigit(IN = getchar()))
if (IN == '-') NEG = 1;
x = IN - '0';
while (isdigit(IN = getchar())) x = x * 10 + IN - '0';
if (NEG) x = -x;
}
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
const int maxp = 10001;
int dcmp(double d) {
if (fabs(d) < eps) return 0;
return d > eps ? 1 : -1;
}
inline double sqr(double x) { return x * x; }
struct point {
double x, y;
point() {}
point(double _x, double _y) : x(_x), y(_y){};
void input() { scanf("%lf%lf", &x, &y); }
void output() { printf("%.2f %.2f\n", x, y); }
bool operator==(point a) const {
return dcmp(a.x - x) == 0 && dcmp(a.y - y) == 0;
}
bool operator<(point a) const {
return dcmp(a.x - x) == 0 ? dcmp(y - a.y) < 0 : x < a.x;
}
double len() { return hypot(x, y); }
double len2() { return x * x + y * y; }
double distance(point p) { return hypot(x - p.x, y - p.y); }
point add(point p) { return point(x + p.x, y + p.y); }
point sub(point p) { return point(x - p.x, y - p.y); }
point mul(double b) { return point(x * b, y * b); }
point div(double b) { return point(x / b, y / b); }
double dot(point p) { return x * p.x + y * p.y; }
double det(point p) { return x * p.y - y * p.x; }
double rad(point a, point b) {
point p = *this;
return fabs(atan2(fabs(a.sub(p).det(b.sub(p))), a.sub(p).dot(b.sub(p))));
}
point trunc(double r) {
double l = len();
if (!dcmp(l)) return *this;
r /= l;
return point(x * r, y * r);
}
point rotleft() { return point(-y, x); }
point rotright() { return point(y, -x); }
point rotate(point p, double angle) {
point v = this->sub(p);
double c = cos(angle), s = sin(angle);
return point(p.x + v.x * c - v.y * s, p.y + v.x * s + v.y * c);
}
};
struct line {
point a, b;
line() {}
line(point _a, point _b) {
a = _a;
b = _b;
}
bool operator==(line v) { return (a == v.a) && (b == v.b); }
line(point p, double angle) {
a = p;
if (dcmp(angle - pi / 2) == 0) {
b = a.add(point(0, 1));
} else {
b = a.add(point(1, tan(angle)));
}
}
line(double _a, double _b, double _c) {
if (dcmp(_a) == 0) {
a = point(0, -_c / _b);
b = point(1, -_c / _b);
} else if (dcmp(_b) == 0) {
a = point(-_c / _a, 0);
b = point(-_c / _a, 1);
} else {
a = point(0, -_c / _b);
b = point(1, (-_c - _a) / _b);
}
}
void input() {
a.input();
b.input();
}
void adjust() {
if (b < a) swap(a, b);
}
double length() { return a.distance(b); }
double angle() {
double k = atan2(b.y - a.y, b.x - a.x);
if (dcmp(k) < 0) k += pi;
if (dcmp(k - pi) == 0) k -= pi;
return k;
}
int relation(point p) {
int c = dcmp(p.sub(a).det(b.sub(a)));
if (c < 0) return 1;
if (c > 0) return 2;
return 3;
}
bool pointonseg(point p) {
return dcmp(p.sub(a).det(b.sub(a))) == 0 &&
dcmp(p.sub(a).dot(p.sub(b))) <= 0;
}
bool parallel(line v) { return dcmp(b.sub(a).det(v.b.sub(v.a))) == 0; }
int segcrossseg(line v) {
int d1 = dcmp(b.sub(a).det(v.a.sub(a)));
int d2 = dcmp(b.sub(a).det(v.b.sub(a)));
int d3 = dcmp(v.b.sub(v.a).det(a.sub(v.a)));
int d4 = dcmp(v.b.sub(v.a).det(b.sub(v.a)));
if ((d1 ^ d2) == -2 && (d3 ^ d4) == -2) return 2;
return ((d1 == 0 && dcmp(v.a.sub(a).dot(v.a.sub(b))) <= 0) ||
(d2 == 0 && dcmp(v.b.sub(a).dot(v.b.sub(b))) <= 0) ||
(d3 == 0 && dcmp(a.sub(v.a).dot(a.sub(v.b))) <= 0) ||
(d4 == 0 && dcmp(b.sub(v.a).dot(b.sub(v.b))) <= 0));
}
int linecrossseg(line v) {
int d1 = dcmp(b.sub(a).det(v.a.sub(a)));
int d2 = dcmp(b.sub(a).det(v.b.sub(a)));
if ((d1 ^ d2) == -2) return 2;
return (d1 == 0 || d2 == 0);
}
int linecrossline(line v) {
if ((*this).parallel(v)) return v.relation(a) == 3;
return 2;
}
point crosspoint(line v) {
double a1 = v.b.sub(v.a).det(a.sub(v.a));
double a2 = v.b.sub(v.a).det(b.sub(v.a));
return point((a.x * a2 - b.x * a1) / (a2 - a1),
(a.y * a2 - b.y * a1) / (a2 - a1));
}
double dispointtoline(point p) {
return fabs(p.sub(a).det(b.sub(a))) / length();
}
double dispointtoseg(point p) {
if (dcmp(p.sub(b).dot(a.sub(b))) < 0 || dcmp(p.sub(a).dot(b.sub(a))) < 0)
return min(p.distance(a), p.distance(b));
return dispointtoline(p);
}
point lineprog(point p) {
return a.add(b.sub(a).mul(b.sub(a).dot(p.sub(a)) / b.sub(a).len2()));
}
point symmetrypoint(point p) {
point q = lineprog(p);
return point(2 * q.x - p.x, 2 * q.y - p.y);
}
};
struct circle {
point p;
double r;
circle() {}
circle(point _p, double _r) : p(_p), r(_r){};
circle(double x, double y, double _r) : p(point(x, y)), r(_r){};
circle(point a, point b, point c) {
p = line(a.add(b).div(2), a.add(b).div(2).add(b.sub(a).rotleft()))
.crosspoint(
line(c.add(b).div(2), c.add(b).div(2).add(b.sub(c).rotleft())));
r = p.distance(a);
}
circle(point a, point b, point c, bool t) {
line u, v;
double m = atan2(b.y - a.y, b.x - a.x), n = atan2(c.y - a.y, c.x - a.x);
u.a = a;
u.b = u.a.add(point(cos((n + m) / 2), sin((n + m) / 2)));
v.a = b;
m = atan2(a.y - b.y, a.x - b.x), n = atan2(c.y - b.y, c.x - b.x);
v.b = v.a.add(point(cos((n + m) / 2), sin((n + m) / 2)));
p = u.crosspoint(v);
r = line(a, b).dispointtoseg(p);
}
void input() {
p.input();
scanf("%lf", &r);
}
void output() { printf("%.2lf %.2lf %.2lf\n", p.x, p.y, r); }
bool operator==(circle v) { return ((p == v.p) && dcmp(r - v.r) == 0); }
bool operator<(circle v) const {
return ((p < v.p) || ((p == v.p) && dcmp(r - v.r) < 0));
}
double area() { return pi * sqr(r); }
double circumference() { return 2 * pi * r; }
int relation(point b) {
double dst = b.distance(p);
if (dcmp(dst - r) < 0) return 2;
if (dcmp(dst - r) == 0) return 1;
return 0;
}
int relationseg(line v) {
double dst = v.dispointtoseg(p);
if (dcmp(dst - r) < 0) return 2;
if (dcmp(dst - r) == 0) return 1;
return 0;
}
int relationline(line v) {
double dst = v.dispointtoline(p);
if (dcmp(dst - r) < 0) return 2;
if (dcmp(dst - r) == 0) return 1;
return 0;
}
int getcircle(point a, point b, double r, circle &c1, circle &c2) {
circle x(a, r), y(b, r);
int t = x.pointcrosscircle(y, c1.p, c2.p);
if (!t) return 0;
c1.r = c2.r = r;
return t;
}
int getcircle(line u, point q, double r1, circle &c1, circle &c2) {
double dis = u.dispointtoline(q);
if (dcmp(dis - r1 * 2) > 0) return 0;
if (dcmp(dis) == 0) {
c1.p = q.add(u.b.sub(u.a).rotleft().trunc(r1));
c2.p = q.add(u.b.sub(u.a).rotright().trunc(r1));
c1.r = c2.r = r1;
return 2;
}
line u1 = line(u.a.add(u.b.sub(u.a).rotleft().trunc(r1)),
u.b.add(u.b.sub(u.a).rotleft().trunc(r1)));
line u2 = line(u.a.add(u.b.sub(u.a).rotright().trunc(r1)),
u.b.add(u.b.sub(u.a).rotright().trunc(r1)));
circle cc = circle(q, r1);
point p1, p2;
if (!cc.pointcrossline(u1, p1, p2)) cc.pointcrossline(u2, p1, p2);
c1 = circle(p1, r1);
if (p1 == p2) {
c2 = c1;
return 1;
}
c2 = circle(p2, r1);
return 2;
}
int getcircle(line u, line v, double r1, circle &c1, circle &c2, circle &c3,
circle &c4) {
if (u.parallel(v)) return 0;
line u1 = line(u.a.add(u.b.sub(u.a).rotleft().trunc(r1)),
u.b.add(u.b.sub(u.a).rotleft().trunc(r1)));
line u2 = line(u.a.add(u.b.sub(u.a).rotright().trunc(r1)),
u.b.add(u.b.sub(u.a).rotright().trunc(r1)));
line v1 = line(v.a.add(v.b.sub(v.a).rotleft().trunc(r1)),
v.b.add(v.b.sub(v.a).rotleft().trunc(r1)));
line v2 = line(v.a.add(v.b.sub(v.a).rotright().trunc(r1)),
v.b.add(v.b.sub(v.a).rotright().trunc(r1)));
c1.r = c2.r = c3.r = c4.r = r1;
c1.p = u1.crosspoint(v1);
c2.p = u1.crosspoint(v2);
c3.p = u2.crosspoint(v1);
c4.p = u2.crosspoint(v2);
return 4;
}
int getcircle(circle cx, circle cy, double r1, circle &c1, circle &c2) {
circle x(cx.p, r1 + cx.r), y(cy.p, r1 + cy.r);
int t = x.pointcrosscircle(y, c1.p, c2.p);
if (!t) return 0;
c1.r = c2.r = r1;
return t;
}
int pointcrossline(line v, point &p1, point &p2) {
if (!(*this).relationline(v)) return 0;
point a = v.lineprog(p);
double d = v.dispointtoline(p);
d = sqrt(r * r - d * d);
if (dcmp(d) == 0) {
p1 = a;
p2 = a;
return 1;
}
p1 = a.sub(v.b.sub(v.a).trunc(d));
p2 = a.add(v.b.sub(v.a).trunc(d));
return 2;
}
int relationcircle(circle v) {
double d = p.distance(v.p);
if (dcmp(d - r - v.r) > 0) return 5;
if (dcmp(d - r - v.r) == 0) return 4;
double l = fabs(r - v.r);
if (dcmp(d - r - v.r) < 0 && dcmp(d - l) > 0) return 3;
if (dcmp(d - l) == 0) return 2;
if (dcmp(d - l) < 0) return 1;
}
int pointcrosscircle(circle v, point &p1, point &p2) {
int rel = relationcircle(v);
if (rel == 1 || rel == 5) return 0;
double d = p.distance(v.p);
double l = (d + (sqr(r) - sqr(v.r)) / d) / 2;
double h = sqrt(sqr(r) - sqr(l));
p1 = p.add(v.p.sub(p).trunc(l).add(v.p.sub(p).rotleft().trunc(h)));
p2 = p.add(v.p.sub(p).trunc(l).add(v.p.sub(p).rotright().trunc(h)));
if (rel == 2 || rel == 4) return 1;
return 2;
}
int tangentline(point q, line &u, line &v) {
int x = relation(q);
if (x == 2) return 0;
if (x == 1) {
u = line(q, q.add(q.sub(p).rotleft()));
v = u;
return 1;
}
double d = p.distance(q);
double l = sqr(r) / d;
double h = sqrt(sqr(r) - sqr(l));
u = line(q, p.add(q.sub(p).trunc(l).add(q.sub(p).rotleft().trunc(h))));
v = line(q, p.add(q.sub(p).trunc(l).add(q.sub(p).rotright().trunc(h))));
return 2;
}
double areacircle(circle v) {
int rel = relationcircle(v);
if (rel >= 4) return 0.0;
if (rel <= 2) return min(area(), v.area());
double d = p.distance(v.p);
double hf = (r + v.r + d) / 2.0;
double ss = 2 * sqrt(hf * (hf - r) * (hf - v.r) * (hf - d));
double a1 = acos((r * r + d * d - v.r * v.r) / (2.0 * r * d));
a1 = a1 * r * r;
double a2 = acos((v.r * v.r + d * d - r * r) / (2.0 * v.r * d));
a2 = a2 * v.r * v.r;
return a1 + a2 - ss;
}
double areatriangle(point a, point b) {
if (dcmp(p.sub(a).det(p.sub(b)) == 0)) return 0.0;
point q[5];
int len = 0;
q[len++] = a;
line l(a, b);
point p1, p2;
if (pointcrossline(l, q[1], q[2]) == 2) {
if (dcmp(a.sub(q[1]).dot(b.sub(q[1]))) < 0) q[len++] = q[1];
if (dcmp(a.sub(q[2]).dot(b.sub(q[2]))) < 0) q[len++] = q[2];
}
q[len++] = b;
if (len == 4 && (dcmp(q[0].sub(q[1]).dot(q[2].sub(q[1]))) > 0))
swap(q[1], q[2]);
double res = 0;
int i;
for (i = 0; i < len - 1; i++) {
if (relation(q[i]) == 0 || relation(q[i + 1]) == 0) {
double arg = p.rad(q[i], q[i + 1]);
res += r * r * arg / 2.0;
} else
res += fabs(q[i].sub(p).det(q[i + 1].sub(p)) / 2.0);
}
return res;
}
};
struct polygon {
int n;
point p[maxp];
line l[maxp];
void input() {
for (int i = 0; i < n; i++) p[i].input();
}
void add(point q) { p[n++] = q; }
void getline() {
for (int i = 0; i < n; i++) l[i] = line(p[i], p[(i + 1) % n]);
}
struct cmp {
point p;
cmp(const point &p0) { p = p0; }
bool operator()(const point &aa, const point &bb) {
point a = aa, b = bb;
int d = dcmp(a.sub(p).det(b.sub(p)));
if (d == 0) return dcmp(a.distance(p) - b.distance(p)) < 0;
return d > 0;
}
};
void norm() {
point mi = p[0];
for (int i = 1; i < n; i++) mi = min(mi, p[i]);
sort(p, p + n, cmp(mi));
}
void getconvex(polygon &convex) {
int i;
sort(p, p + n);
convex.n = n;
for (i = 0; i < min(n, 2); i++) convex.p[i] = p[i];
if (n <= 2) return;
int &top = convex.n;
top = 1;
for (i = 2; i < n; i++) {
while (top &&
convex.p[top].sub(p[i]).det(convex.p[top - 1].sub(p[i])) <= 0)
top--;
convex.p[++top] = p[i];
}
int temp = top;
convex.p[++top] = p[n - 2];
for (i = n - 3; i >= 0; i--) {
while (top != temp &&
convex.p[top].sub(p[i]).det(convex.p[top - 1].sub(p[i])) <= 0)
top--;
convex.p[++top] = p[i];
}
}
bool isconvex() {
bool s[3];
memset(s, 0, sizeof(s));
int i, j, k;
for (i = 0; i < n; i++) {
j = (i + 1) % n;
k = (j + 1) % n;
s[dcmp(p[j].sub(p[i]).det(p[k].sub(p[i]))) + 1] = 1;
if (s[0] && s[2]) return 0;
}
return 1;
}
int relationpoint(point q) {
int i, j;
for (i = 0; i < n; i++)
if (p[i] == q) return 3;
getline();
for (i = 0; i < n; i++)
if (l[i].pointonseg(q)) return 2;
int cnt = 0;
for (i = 0; i < n; i++) {
j = (i + 1) % n;
int k = dcmp(q.sub(p[j]).det(p[i].sub(p[j])));
int u = dcmp(p[i].y - q.y);
int v = dcmp(p[j].y - q.y);
if (k > 0 && u < 0 && v >= 0) cnt++;
if (k < 0 && v < 0 && u >= 0) cnt--;
}
return cnt != 0;
}
int relationline(line u) {
int i, k = 0;
getline();
for (i = 0; i < n; i++) {
if (l[i].segcrossseg(u) == 2) return 1;
if (l[i].segcrossseg(u) == 1) k = 1;
}
if (!k) return 0;
vector<point> vp;
for (i = 0; i < n; i++) {
if (l[i].segcrossseg(u)) {
if (l[i].parallel(u)) {
vp.push_back(u.a);
vp.push_back(u.b);
vp.push_back(l[i].a);
vp.push_back(l[i].b);
continue;
}
vp.push_back(l[i].crosspoint(u));
}
}
sort(vp.begin(), vp.end());
int sz = vp.size();
for (i = 0; i < sz - 1; i++) {
point mid = vp[i].add(vp[i + 1]).div(2);
if (relationpoint(mid) == 1) return 1;
}
return 2;
}
void convexcut(line u, polygon &po) {
int i;
int &top = po.n;
top = 0;
for (i = 0; i < n; i++) {
int d1 = dcmp(p[i].sub(u.a).det(u.b.sub(u.a)));
int d2 = dcmp(p[(i + 1) % n].sub(u.a).det(u.b.sub(u.a)));
if (d1 >= 0) po.p[top++] = p[i];
if (d1 * d2 < 0) po.p[top++] = u.crosspoint(line(p[i], p[(i + 1) % n]));
}
}
double getcircumference() {
double sum = 0;
int i;
for (i = 0; i < n; i++) sum += p[i].distance(p[(i + 1) % n]);
return sum;
}
double getarea() {
double sum = 0;
for (int i = 0; i < n; i++) sum += p[i].det(p[(i + 1) % n]);
return fabs(sum) / 2;
}
bool getdir() {
double sum = 0;
int i;
for (i = 0; i < n; i++) sum += p[i].det(p[(i + 1) % n]);
if (dcmp(sum) > 0) return 1;
return 0;
}
point getbarycentre() {
point ret(0, 0);
double area = 0;
int i;
for (i = 1; i < n - 1; i++) {
double tmp = p[i].sub(p[0]).det(p[i + 1].sub(p[0]));
if (dcmp(tmp) == 0) continue;
area += tmp;
ret.x += (p[0].x + p[i].x + p[i + 1].x) / 3 * tmp;
ret.y += (p[0].y + p[i].y + p[i + 1].y) / 3 * tmp;
}
if (dcmp(area)) ret = ret.div(area);
return ret;
}
double areacircle(circle c) {
int i;
double ans = 0;
for (i = 0; i < n; i++) {
int j = (i + 1) % n;
if (dcmp(p[j].sub(c.p).det(p[i].sub(c.p))) >= 0)
ans += c.areatriangle(p[i], p[j]);
else
ans -= c.areatriangle(p[i], p[j]);
}
return fabs(ans);
}
int relationcircle(circle c) {
getline();
int i, x = 2;
if (relationpoint(c.p) != 1) return 0;
for (i = 0; i < n; i++) {
if (c.relationseg(l[i]) == 2) return 0;
if (c.relationseg(l[i]) == 1) x = 1;
}
return x;
}
void find(int st, point tri[], circle &c) {
if (!st) c = circle(point(0, 0), -2);
if (st == 1) c = circle(tri[0], 0);
if (st == 2)
c = circle(tri[0].add(tri[1]).div(2), tri[0].distance(tri[1]) / 2.0);
if (st == 3) c = circle(tri[0], tri[1], tri[2]);
}
void solve(int cur, int st, point tri[], circle &c) {
find(st, tri, c);
if (st == 3) return;
int i;
for (i = 0; i < cur; i++)
if (dcmp(p[i].distance(c.p) - c.r) > 0) {
tri[st] = p[i];
solve(i, st + 1, tri, c);
}
}
circle mincircle() {
random_shuffle(p, p + n);
point tri[4];
circle c;
solve(n, 0, tri, c);
return c;
}
int circlecover(double r) {
int ans = 0, i, j;
vector<pair<double, int> > v;
for (i = 0; i < n; i++) {
v.clear();
for (j = 0; j < n; j++)
if (i != j) {
point q = p[i].sub(p[j]);
double d = q.len();
if (dcmp(d - 2 * r) <= 0) {
double arg = atan2(q.y, q.x);
if (dcmp(arg) < 0) arg += 2 * pi;
double t = acos(d / (2 * r));
v.push_back(make_pair(arg - t + 2 * pi, -1));
v.push_back(make_pair(arg + t + 2 * pi, 1));
}
}
sort(v.begin(), v.end());
int cur = 0;
for (j = 0; j < int(v.size()); j++) {
if (v[j].second == -1)
++cur;
else
--cur;
ans = max(ans, cur);
}
}
return ans + 1;
}
int pointinpolygon(point q) {
if (getdir()) reverse(p, p + n);
if (dcmp(q.sub(p[0]).det(p[n - 1].sub(p[0]))) == 0) {
if (line(p[n - 1], p[0]).pointonseg(q)) return n - 1;
return -1;
}
int low = 1, high = n - 2, mid;
while (low <= high) {
mid = (low + high) >> 1;
if (dcmp(q.sub(p[0]).det(p[mid].sub(p[0]))) >= 0 &&
dcmp(q.sub(p[0]).det(p[mid + 1].sub(p[0]))) < 0) {
polygon c;
c.p[0] = p[mid];
c.p[1] = p[mid + 1];
c.p[2] = p[0];
c.n = 3;
if (c.relationpoint(q)) return mid;
return -1;
}
if (dcmp(q.sub(p[0]).det(p[mid].sub(p[0]))) > 0)
low = mid + 1;
else
high = mid - 1;
}
return -1;
}
};
struct polygons {
vector<polygon> p;
polygons() { p.clear(); }
void clear() { p.clear(); }
void push(polygon q) {
if (dcmp(q.getarea())) p.push_back(q);
}
vector<pair<double, int> > e;
void ins(point s, point t, point X, int i) {
double r = fabs(t.x - s.x) > eps ? (X.x - s.x) / (t.x - s.x)
: (X.y - s.y) / (t.y - s.y);
r = min(r, 1.0);
r = max(r, 0.0);
e.push_back(make_pair(r, i));
}
double polyareaunion() {
double ans = 0.0;
int c0, c1, c2, i, j, k, w;
for (i = 0; i < int(p.size()); i++)
if (p[i].getdir() == 0) reverse(p[i].p, p[i].p + p[i].n);
for (i = 0; i < int(p.size()); i++) {
for (k = 0; k < p[i].n; k++) {
point &s = p[i].p[k], &t = p[i].p[(k + 1) % p[i].n];
if (!dcmp(s.det(t))) continue;
e.clear();
e.push_back(make_pair(0.0, 1));
e.push_back(make_pair(1.0, -1));
for (j = 0; j < int(p.size()); j++)
if (i != j) {
for (w = 0; w < p[j].n; w++) {
point a = p[j].p[w], b = p[j].p[(w + 1) % p[j].n],
c = p[j].p[(w - 1 + p[j].n) % p[j].n];
c0 = dcmp(t.sub(s).det(c.sub(s)));
c1 = dcmp(t.sub(s).det(a.sub(s)));
c2 = dcmp(t.sub(s).det(b.sub(s)));
if (c1 * c2 < 0)
ins(s, t, line(s, t).crosspoint(line(a, b)), -c2);
else if (!c1 && c0 * c2 < 0)
ins(s, t, a, -c2);
else if (!c1 && !c2) {
int c3 = dcmp(t.sub(s).det(p[j].p[(w + 2) % p[j].n].sub(s)));
int dp = dcmp(t.sub(s).dot(b.sub(a)));
if (dp && c0)
ins(s, t, a, dp > 0 ? c0 * ((j > i) ^ (c0 < 0)) : -(c0 < 0));
if (dp && c3)
ins(s, t, b, dp > 0 ? -c3 * ((j > i) ^ (c3 < 0)) : c3 < 0);
}
}
}
sort(e.begin(), e.end());
int ct = 0;
double tot = 0.0, last;
for (j = 0; j < int(e.size()); j++) {
if (ct == 2) tot += e[j].first - last;
ct += e[j].second;
last = e[j].first;
}
ans += s.det(t) * tot;
}
}
return fabs(ans) * 0.5;
}
};
const int maxn = 500;
struct circles {
circle c[maxn];
double ans[maxn];
double pre[maxn];
int n;
circles() {}
void add(circle cc) { c[n++] = cc; }
bool inner(circle x, circle y) {
if (x.relationcircle(y) != 1) return 0;
return dcmp(x.r - y.r) <= 0 ? 1 : 0;
}
void init_or() {
int i, j, k = 0;
bool mark[maxn] = {0};
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (i != j && !mark[j])
if ((c[i] == c[j]) || inner(c[i], c[j])) break;
if (j < n) mark[i] = 1;
}
for (i = 0; i < n; i++)
if (!mark[i]) c[k++] = c[i];
n = k;
}
void init_and() {
int i, j, k = 0;
bool mark[maxn] = {0};
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (i != j && !mark[j])
if ((c[i] == c[j]) || inner(c[j], c[i])) break;
if (j < n) mark[i] = 1;
}
for (i = 0; i < n; i++)
if (!mark[i]) c[k++] = c[i];
n = k;
}
double areaarc(double th, double r) { return 0.5 * sqr(r) * (th - sin(th)); }
void getarea() {
int i, j;
memset(ans, 0, sizeof(ans));
vector<pair<double, int> > v;
for (i = 0; i < n; i++) {
v.clear();
v.push_back(make_pair(-pi, 1));
v.push_back(make_pair(pi, -1));
for (j = 0; j < n; j++)
if (i != j) {
point q = c[j].p.sub(c[i].p);
double ab = q.len(), ac = c[i].r, bc = c[j].r;
if (dcmp(ab + ac - bc) <= 0) {
v.push_back(make_pair(-pi, 1));
v.push_back(make_pair(pi, -1));
continue;
}
if (dcmp(ab + bc - ac) <= 0) continue;
if (dcmp(ab - ac - bc) > 0) continue;
double th = atan2(q.y, q.x),
fai = acos((ac * ac + ab * ab - bc * bc) / (2.0 * ac * ab));
double a0 = th - fai;
if (dcmp(a0 + pi) < 0) a0 += 2 * pi;
double a1 = th + fai;
if (dcmp(a1 - pi) > 0) a1 -= 2 * pi;
if (dcmp(a0 - a1) > 0) {
v.push_back(make_pair(a0, 1));
v.push_back(make_pair(pi, -1));
v.push_back(make_pair(-pi, 1));
v.push_back(make_pair(a1, -1));
} else {
v.push_back(make_pair(a0, 1));
v.push_back(make_pair(a1, -1));
}
}
sort(v.begin(), v.end());
int cur = 0;
for (j = 0; j < int(v.size()); j++) {
if (cur && dcmp(v[j].first - pre[cur])) {
ans[cur] += areaarc(v[j].first - pre[cur], c[i].r);
ans[cur] +=
0.5 * point(c[i].p.x + c[i].r * cos(pre[cur]),
c[i].p.y + c[i].r * sin(pre[cur]))
.det(point(c[i].p.x + c[i].r * cos(v[j].first),
c[i].p.y + c[i].r * sin(v[j].first)));
}
cur += v[j].second;
pre[cur] = v[j].first;
}
}
for (i = 1; i <= n; i++) {
ans[i] -= ans[i + 1];
}
}
};
struct halfplane : public line {
double angle;
halfplane() {}
halfplane(point _a, point _b) {
a = _a;
b = _b;
}
halfplane(line v) {
a = v.a;
b = v.b;
}
void calcangle() { angle = atan2(b.y - a.y, b.x - a.x); }
bool operator<(const halfplane &b) const { return angle < b.angle; }
};
struct halfplanes {
int n;
halfplane hp[maxp];
point p[maxp];
int que[maxp];
int st, ed;
void push(halfplane tmp) { hp[n++] = tmp; }
void unique() {
int m = 1, i;
for (i = 1; i < n; i++) {
if (dcmp(hp[i].angle - hp[i - 1].angle))
hp[m++] = hp[i];
else if (dcmp(hp[m - 1].b.sub(hp[m - 1].a).det(hp[i].a.sub(hp[m - 1].a)) >
0))
hp[m - 1] = hp[i];
}
n = m;
}
bool halfplaneinsert() {
int i;
for (i = 0; i < n; i++) hp[i].calcangle();
sort(hp, hp + n);
unique();
que[st = 0] = 0;
que[ed = 1] = 1;
p[1] = hp[0].crosspoint(hp[1]);
for (i = 2; i < n; i++) {
while (st < ed &&
dcmp((hp[i].b.sub(hp[i].a).det(p[ed].sub(hp[i].a)))) < 0)
ed--;
while (st < ed &&
dcmp((hp[i].b.sub(hp[i].a).det(p[st + 1].sub(hp[i].a)))) < 0)
st++;
que[++ed] = i;
if (hp[i].parallel(hp[que[ed - 1]])) return false;
p[ed] = hp[i].crosspoint(hp[que[ed - 1]]);
}
while (
st < ed &&
dcmp(hp[que[st]].b.sub(hp[que[st]].a).det(p[ed].sub(hp[que[st]].a))) <
0)
ed--;
while (st < ed && dcmp(hp[que[ed]]
.b.sub(hp[que[ed]].a)
.det(p[st + 1].sub(hp[que[ed]].a))) < 0)
st++;
if (st + 1 >= ed) return false;
return true;
}
void getconvex(polygon &con) {
p[st] = hp[que[st]].crosspoint(hp[que[ed]]);
con.n = ed - st + 1;
int j = st, i = 0;
for (; j <= ed; i++, j++) con.p[i] = p[j];
}
};
struct point3 {
double x, y, z;
point3() {}
point3(double _x, double _y, double _z) : x(_x), y(_y), z(_z){};
void input() { scanf("%lf%lf%lf", &x, &y, &z); }
void output() { printf("%.2lf %.2lf %.2lf", x, y, z); }
bool operator==(point3 a) {
return dcmp(a.x - x) == 0 && dcmp(a.y - y) == 0 && dcmp(a.z - z) == 0;
}
bool operator<(point3 a) const {
return dcmp(a.x - x) == 0 ? dcmp(y - a.y) == 0 ? dcmp(z - a.z) < 0 : y < a.y
: x < a.x;
}
double len() { return sqrt(len2()); }
double len2() { return x * x + y * y + z * z; }
double distance(point3 p) {
return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y) +
(p.z - z) * (p.z - z));
}
point3 add(point3 p) { return point3(x + p.x, y + p.y, z + p.z); }
point3 sub(point3 p) { return point3(x - p.x, y - p.y, z - p.z); }
point3 mul(double d) { return point3(x * d, y * d, z * d); }
point3 div(double d) { return point3(x / d, y / d, z / d); }
double dot(point3 p) { return x * p.x + y * p.y + z * p.z; }
point3 det(point3 p) {
return point3(y * p.z - p.y * z, p.x * z - x * p.z, x * p.y - p.x * y);
}
double rad(point3 a, point3 b) {
point3 p = (*this);
return acos(a.sub(p).dot(b.sub(p)) / (a.distance(p) * b.distance(p)));
}
point3 trunc(double r) {
r /= len();
return point3(x * r, y * r, z * r);
}
};
struct line3 {
point3 a, b;
line3() {}
line3(point3 _a, point3 _b) {
a = _a;
b = _b;
}
bool operator==(line3 v) { return (a == v.a) && (b == v.b); }
void input() {
a.input();
b.input();
}
double length() { return a.distance(b); }
double dispointtoline(point3 p) {
return b.sub(a).det(p.sub(a)).len() / a.distance(b);
}
double dispointtoseg(point3 p) {
if (dcmp(p.sub(b).dot(a.sub(b))) < 0 || dcmp(p.sub(a).dot(b.sub(a))) < 0)
return min(p.distance(a), p.distance(b));
return dispointtoline(p);
}
point3 lineprog(point3 p) {
return a.add(b.sub(a).trunc(b.sub(a).dot(p.sub(a)) / b.distance(a)));
}
point3 rotate(point3 p, double ang) {
if (dcmp((p.sub(a).det(p.sub(b)).len())) == 0) return p;
point3 f1 = b.sub(a).det(p.sub(a));
point3 f2 = b.sub(a).det(f1);
double len = fabs(a.sub(p).det(b.sub(p)).len() / a.distance(b));
f1 = f1.trunc(len);
f2 = f2.trunc(len);
point3 h = p.add(f2);
point3 pp = h.add(f1);
return h.add((p.sub(h)).mul(cos(ang * 1.0)))
.add((pp.sub(h)).mul(sin(ang * 1.0)));
}
};
struct plane {
point3 a, b, c, o;
plane() {}
plane(point3 _a, point3 _b, point3 _c) {
a = _a;
b = _b;
c = _c;
o = pvec();
}
plane(double _a, double _b, double _c, double _d) {
o = point3(_a, _b, _c);
if (dcmp(_a) != 0)
a = point3((-_d - _c - _b) / _a, 1, 1);
else if (dcmp(_b) != 0)
a = point3(1, (-_d - _c - _a) / _b, 1);
else if (dcmp(_c) != 0)
a = point3(1, 1, (-_d - _a - _b) / _c);
}
void input() {
a.input();
b.input();
c.input();
o = pvec();
}
point3 pvec() { return b.sub(a).det(c.sub(a)); }
bool pointonplane(point3 p) { return dcmp(p.sub(a).dot(o)) == 0; }
double angleplane(plane f) {
return acos(o.dot(f.o) / (o.len() * f.o.len()));
}
double dispoint(point3 p) { return fabs(p.sub(a).dot(o) / o.len()); }
point3 pttoplane(point3 p) {
line3 u = line3(p, p.add(o));
crossline(u, p);
return p;
}
int crossline(line3 u, point3 &p) {
double x = o.dot(u.b.sub(a));
double y = o.dot(u.a.sub(a));
double d = x - y;
if (dcmp(fabs(d)) == 0) return 0;
p = u.a.mul(x).sub(u.b.mul(y)).div(d);
return 1;
}
int crossplane(plane f, line3 &u) {
point3 oo = o.det(f.o);
point3 v = o.det(oo);
double d = fabs(f.o.dot(v));
if (dcmp(d) == 0) return 0;
point3 q = a.add(v.mul(f.o.dot(f.a.sub(a)) / d));
u = line3(q, q.add(oo));
return 1;
}
};
const int MAXN = 1e5 + 5;
int q[MAXN];
long long a[MAXN], b[MAXN];
long long dp[MAXN];
double g(int j, int k) { return (dp[k] - dp[j]) * 1.0 / (b[j] - b[k]); }
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) LL(a[i]);
for (int i = 1; i <= n; i++) LL(b[i]);
memset(dp, 0, sizeof(dp));
int h = 0, t = 0;
q[++t] = 1;
for (int i = 2; i <= n; i++) {
while (h + 1 < t && g(q[h + 1], q[h + 2]) < a[i]) ++h;
dp[i] = dp[q[h + 1]] + a[i] * b[q[h + 1]];
while (h + 1 < t && g(q[t], i) <= g(q[t - 1], q[t])) --t;
q[++t] = i;
}
cout << dp[n] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
long long from, to, capacity, cost;
};
vector<vector<long long>> adj, cost, capacity;
const long long INF = 1e18;
void shortest_paths(long long n, long long v0, vector<long long>& d,
vector<long long>& p) {
d.assign(n, INF);
d[v0] = 0;
vector<bool> inq(n, false);
queue<long long> q;
q.push(v0);
p.assign(n, -1);
while (!q.empty()) {
long long u = q.front();
q.pop();
inq[u] = false;
for (long long v : adj[u]) {
if (capacity[u][v] > 0 && d[v] > d[u] + cost[u][v]) {
d[v] = d[u] + cost[u][v];
p[v] = u;
if (!inq[v]) {
inq[v] = true;
q.push(v);
}
}
}
}
}
long long min_cost_flow(long long N, vector<Edge> edges, long long K,
long long s, long long t) {
adj.assign(N, vector<long long>());
cost.assign(N, vector<long long>(N, 0));
capacity.assign(N, vector<long long>(N, 0));
for (Edge e : edges) {
adj[e.from].push_back(e.to);
adj[e.to].push_back(e.from);
cost[e.from][e.to] = e.cost;
cost[e.to][e.from] = -e.cost;
capacity[e.from][e.to] = e.capacity;
}
long long flow = 0;
long long cost = 0;
vector<long long> d, p;
while (flow < K) {
shortest_paths(N, s, d, p);
if (d[t] == INF) break;
long long f = K - flow;
long long cur = t;
while (cur != s) {
f = min(f, capacity[p[cur]][cur]);
cur = p[cur];
}
flow += f;
cost += f * d[t];
cur = t;
while (cur != s) {
capacity[p[cur]][cur] -= f;
capacity[cur][p[cur]] += f;
cur = p[cur];
}
}
if (flow < K)
return -1;
else
return cost;
}
long long n, k, a[1000100], b[1000100];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
}
vector<Edge> edges;
for (long long i = 0; i < n; i++) {
Edge e1{0, i + 1, 1, a[i]};
Edge e2{i + 1, n + 1, 1, b[i]};
edges.push_back(e1);
edges.push_back(e2);
if (i == n - 1) continue;
Edge e3{i + 1, i + 2, k, 0};
edges.push_back(e3);
}
cout << min_cost_flow(n + 2, edges, k, 0, n + 1);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s += ',';
set<int> se;
int k = s.find(',');
while (k != string::npos) {
char s1[100];
for (int i = 0; i < 100; i++) {
s1[i] = 0;
}
for (int i = 0; i < k; i++) {
s1[i] = s[i];
}
int p = atoi(s1);
if (!se.count(p)) {
se.insert(p);
}
s.erase(0, k + 1);
k = s.find(',');
}
set<int>::iterator ite = se.begin();
int beg = *se.begin();
for (set<int>::iterator iter = ++se.begin(); iter != se.end(); iter++) {
if ((*iter) == ((*ite) + 1)) {
ite = iter;
} else {
if (*(ite)-beg > 0) {
cout << beg << '-' << *(ite);
} else {
cout << beg;
}
cout << ',';
beg = (*iter);
ite = iter;
}
}
if (*(ite)-beg > 1) {
cout << beg << '-' << *(ite);
} else {
cout << beg;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, s, ans, p, r, t, q, m, x, y, x1, y1, l;
long long a[100002], b[10002];
cin >> n;
map<long long, long long> A;
for (i = 1; i < n; i++) {
cin >> a[i];
A[a[i]] = 1;
}
for (i = 1; i <= n; i++) {
if (A[i] == 0) {
cout << i << endl;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int UI;
typedef long int LI;
typedef unsigned long int ULI;
typedef long long int LL;
typedef unsigned long long int ULL;
LL mod = 1e9 + 7;
inline int scanInt() {
int n = 0;
char ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 1) + (n << 3) + (int)(ch - '0');
ch = getchar();
}
return n * sign;
}
inline LL scanLong() {
LL n = 0;
char ch = getchar();
LL sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 1) + (n << 3) + (LL)(ch - '0');
ch = getchar();
}
return n * sign;
}
int main() {
LL n = scanLong();
;
printf("%lld ", (n % 2));
printf("\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int oo = 1e9, bpr = 1e9 + 7, N = 110;
int a[N][N];
bool f1[N], f2[N];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> a[i][j];
for (int run = 1; run;) {
run = 0;
for (int i = 1; i <= n; ++i) {
int sum = 0;
for (int j = 1; j <= m; ++j) sum += a[i][j];
if (sum < 0) {
run = 1;
f1[i] ^= 1;
for (int j = 1; j <= m; ++j) a[i][j] = -a[i][j];
}
}
for (int j = 1; j <= m; ++j) {
int sum = 0;
for (int i = 1; i <= n; ++i) sum += a[i][j];
if (sum < 0) {
run = 1;
f2[j] ^= 1;
for (int i = 1; i <= n; ++i) a[i][j] = -a[i][j];
}
}
}
vector<int> ans1, ans2;
for (int i = 1; i <= n; ++i)
if (f1[i]) ans1.emplace_back(i);
for (int i = 1; i <= m; ++i)
if (f2[i]) ans2.emplace_back(i);
cout << ans1.size() << " ";
for (auto it : ans1) cout << it << " ";
cout << "\n";
cout << ans2.size() << " ";
for (auto it : ans2) cout << it << " ";
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, q, a[N], lazy[N << 2];
struct node {
int mn, mx, x1, x2, ans;
inline void operator+=(int x) {
mn += x, mx += x;
x1 -= x, x2 -= x;
}
} seg[N << 2];
string s;
inline void smin(int &a, int b) { a = min(a, b); }
inline void smax(int &a, int b) { a = max(a, b); }
inline node merge(node a, node b) {
node c = {min(a.mn, b.mn), max(a.mx, b.mx), max(a.x1, b.x1), max(a.x2, b.x2),
max(a.ans, b.ans)};
smax(c.x1, a.mx - 2 * b.mn), smax(c.x2, b.mx - 2 * a.mn);
smax(c.ans, max(a.x1 + b.mx, a.mx + b.x2));
return c;
}
inline void add(int id, int x) {
seg[id] += x;
lazy[id] += x;
}
inline void shift(int id) {
add(id << 1 | 1, lazy[id]);
add(id << 1, lazy[id]);
lazy[id] = 0;
}
void build(int id = 1, int st = 0, int en = n) {
if (en - st == 1) {
seg[id] = {a[st], a[st], (int)-1e8, (int)-1e8, 0};
return;
}
int mid = st + en >> 1;
build(id << 1, st, mid);
build(id << 1 | 1, mid, en);
seg[id] = merge(seg[id << 1], seg[id << 1 | 1]);
}
void update(int l, int r, int x, int id = 1, int st = 0, int en = n) {
if (r <= st || en <= l) return;
if (l <= st && en <= r) return add(id, x);
shift(id);
int mid = st + en >> 1;
update(l, r, x, id << 1, st, mid);
update(l, r, x, id << 1 | 1, mid, en);
seg[id] = merge(seg[id << 1], seg[id << 1 | 1]);
}
inline void change_pos(int u, int v) {
if (u > v) swap(u, v);
if (s[u] ^ s[v]) {
update(u, v, s[u] ^ '(' ? 2 : -2);
swap(s[u], s[v]);
}
cout << max(seg[1].mx, seg[1].ans) << endl;
}
inline void read_input() {
cin >> n >> q >> s;
n += n - 1;
}
inline void solve() {
for (int i = 0; i < n - 1; i++) a[i + 1] = a[i] + (s[i] ^ ')' ? 1 : -1);
s = "*" + s;
build();
}
inline void write_output() {
change_pos(0, 0);
while (q--) {
int x, y;
cin >> x >> y;
change_pos(x, y);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read_input(), solve(), write_output();
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int built[4];
bool judge() {
sort(built, built + 4);
if (built[0] * 3 == built[3] && built[1] + built[2] == 4 * built[0])
return true;
else
return false;
}
void yes() { printf("YES\n"); }
int main(void) {
int n;
int a[4];
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
if (n == 0)
printf("YES\n1\n1\n3\n3\n");
else if (n == 1)
printf("YES\n%d\n%d\n%d\n", a[0], 3 * a[0], 3 * a[0]);
else if (n == 4) {
sort(a, a + n);
if (a[0] * 3 == a[3] && a[0] + a[3] == a[1] + a[2])
printf("YES\n");
else
printf("NO\n");
} else if (n == 2) {
if (a[0] * 3 == a[1]) {
yes();
printf("%d\n%d\n", a[0], a[1]);
return 0;
} else if (3 * a[0] > a[1]) {
yes();
printf("%d\n%d\n", 4 * a[0] - a[1], 3 * a[0]);
return 0;
} else if ((a[0] + a[1]) % 4 == 0 && (a[0] + a[1]) / 4 <= a[0]) {
yes();
printf("%d\n%d\n", (a[0] + a[1]) / 4, (a[0] + a[1]) / 4 * 3);
return 0;
} else if (a[1] % 3 == 0 && a[1] / 3 <= a[0]) {
yes();
printf("%d\n%d\n", a[1] / 3, a[1] / 3 * 4 - a[0]);
return 0;
}
printf("NO\n");
} else {
for (int i = 1; i <= 1e+6; i++) {
built[n] = i;
built[0] = a[0], built[1] = a[1], built[2] = a[2];
if (judge()) {
printf("YES\n%d\n", i);
return 0;
}
}
printf("NO\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1000001];
int n;
int ans[1000001] = {0};
int sum[1000001] = {0};
unordered_map<int, int> last;
int tree[4000001] = {0};
pair<int, pair<int, int> > query[1000001];
int readInt() {
bool minus = false;
int result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus)
return -result;
else
return result;
}
bool check(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return a.second.second < b.second.second;
}
void update(int p, int v) {
while (p <= n) {
tree[p] = (tree[p] ^ v);
p += (p & (-p));
}
}
int getsum(int p) {
int res = 0;
while (p > 0) {
res = (res ^ tree[p]);
p -= (p & (-p));
}
return res;
}
int main() {
int i, j, k, l, q;
n = readInt();
for (i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] ^ a[i];
}
q = readInt();
for (i = 0; i < q; i++) {
query[i].second.first = readInt();
query[i].second.second = readInt();
query[i].first = i;
}
sort(query, query + q, check);
k = 0;
int an = 0;
i = 1;
for (j = 0; j < q; j++) {
for (; i <= query[j].second.second; i++) {
if (last[a[i]]) update(last[a[i]], a[i]);
update(i, a[i]);
last[a[i]] = i;
}
an = getsum(query[j].second.second) ^ getsum(query[j].second.first - 1);
an = an ^ sum[query[j].second.first - 1] ^ sum[query[j].second.second];
ans[query[j].first] = an;
}
for (i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double m[5], w[5], hs, hu, x[5] = {500, 1000, 1500, 2000, 2500};
double sum = 0;
double q0 = 0, q1 = 0;
double sum2 = 0;
for (int i = 0; i < 5; i++) {
cin >> m[i];
}
for (int i = 0; i < 5; i++) {
cin >> w[i];
}
cin >> hs >> hu;
for (int i = 0; i < 5; i++) {
q0 = 0.3 * x[i];
q1 = ((1 - m[i] / 250) * (x[i])) - (50 * w[i]);
sum = max(q0, q1);
sum2 += sum;
}
sum2 += (hs * 100);
sum2 -= (hu * 50);
cout << sum2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
map<string, int> mp;
int n;
void FileInit() {
{
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
};
}
void FileDebug() {
{
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
freopen(
""
".err",
"w", stderr);
};
}
void FileClose() {
fclose(stdin);
fclose(stdout);
}
int main() {
cin >> n >> s;
for (int i = 0; i < n - 1; ++i) {
string t;
t += s[i];
t += s[i + 1];
mp[t]++;
}
int res1 = -2345678;
string RES;
for (auto x : mp) {
if (res1 < x.second) res1 = x.second, RES = x.first;
}
cout << RES;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
char s[5200] = {0}, next[5200] = {0}, p[5200] = {0}, t[5200] = {0};
while (scanf("%s", s + 1) != EOF) {
s[0] = 'a';
double sum = 0;
int f = 0;
while (sscanf(s, "%*[^0-9]%[0-9.]%[^\0]", p, next) > 0) {
double num1 = 0, num2 = 0;
int len = strlen(p), flag = 0;
if (len > 3 && p[len - 3] == '.') {
sscanf(p + len - 3, "%lf", &num1);
flag = f = 1;
}
if (flag == 1) len = len - 3;
for (int i = 0; i < len; i++) {
if (p[i] == '.') continue;
num2 = num2 * 10 + (p[i] - '0');
}
sum += num1 + num2;
strcpy(s, next);
memset(next, 0, sizeof(next));
}
sprintf(t, "%.2f", sum);
int len = strlen(t), k = 0;
char ans[5200];
if (f == 0) len -= 3;
if (f == 1) {
ans[k++] = t[--len];
ans[k++] = t[--len];
ans[k++] = t[--len];
if (ans[0] == '0' && ans[1] == '0') k = 0;
}
for (int i = len - 1, counts = 1; i >= 0; i--, counts++) {
if (counts % 3 == 1 && counts != 1) ans[k++] = '.';
ans[k++] = t[i];
}
for (int i = k - 1; i >= 0; i--) printf("%c", ans[i]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4, c5, sum;
while (cin >> c1 >> c2 >> c3 >> c4 >> c5) {
sum = c1 + c2 + c3 + c4 + c5;
if (sum % 5 != 0 || sum == 0)
cout << "-1" << endl;
else
cout << sum / 5 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int ans = 0;
if (a >= b) {
ans = a + a / b;
a += -a + a / b + a % b;
while (a >= b) {
ans += a / b;
a += -a + a / b + a % b;
}
} else {
ans = a;
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void file() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void zuka() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int times[300000 + 5];
int l[300000 + 5];
int freq[300000 + 5];
int main() {
zuka();
int n, q, un = 0;
cin >> n >> q;
queue<pair<int, int> > qq;
int i = 1;
while (q--) {
int t, x;
cin >> t >> x;
if (t == 1) {
qq.push({i, x});
times[x] = i;
freq[x]++;
un++;
i++;
} else if (t == 2) {
un -= freq[x];
freq[x] = 0;
l[x] = times[x];
} else if (t == 3) {
while (!qq.empty() && qq.front().first <= x) {
int app = qq.front().second;
int tik = qq.front().first;
if (l[app] < tik) {
un--;
freq[app]--;
}
qq.pop();
}
}
cout << un << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Ret {
int ret[26];
void operator+=(const Ret &r) {
for (int i = 0; i < 26; ++i) {
ret[i] += r.ret[i];
}
}
};
int sum[26][111111 << 2], tag[26][111111 << 2];
int N, x, y, z;
Ret query(int i, int j, int k) {
if (x <= i && j <= y) {
Ret r = {0};
for (int t = 0; t < 26; ++t) r.ret[t] += sum[t][k];
return r;
}
int mid = i + j >> 1;
for (int t = 0; t < 26; ++t) {
if (tag[t][k]) {
tag[t][k << 1] = tag[t][k];
tag[t][k << 1 | 1] = tag[t][k];
if (tag[t][k] == 1) {
sum[t][k << 1] = mid - i + 1;
sum[t][k << 1 | 1] = j - mid;
} else {
sum[t][k << 1] = 0;
sum[t][k << 1 | 1] = 0;
}
tag[t][k] = 0;
}
}
Ret r = {0};
if (x <= mid) r += query(i, mid, k << 1);
if (y > mid) r += query(mid + 1, j, k << 1 | 1);
return r;
}
void update(int i, int j, int k, int flag) {
if (x > y) return;
if (x <= i && j <= y) {
tag[z][k] = flag;
if (flag == 1)
sum[z][k] = j - i + 1;
else
sum[z][k] = 0;
return;
}
int mid = i + j >> 1;
if (tag[z][k]) {
tag[z][k << 1] = tag[z][k];
tag[z][k << 1 | 1] = tag[z][k];
if (tag[z][k] == 1) {
sum[z][k << 1] = mid - i + 1;
sum[z][k << 1 | 1] = j - mid;
} else {
sum[z][k << 1] = 0;
sum[z][k << 1 | 1] = 0;
}
tag[z][k] = 0;
}
if (x <= mid) update(i, mid, k << 1, flag);
if (y > mid) update(mid + 1, j, k << 1 | 1, flag);
sum[z][k] = sum[z][k << 1] + sum[z][k << 1 | 1];
}
char str[111111];
int main() {
int n, m;
scanf("%d%d%s", &n, &m, str + 1);
for (N = 1; N < n; N <<= 1)
;
for (int i = 1; i <= n; ++i) {
x = i;
y = i;
z = str[i] - 'a';
update(1, N, 1, 1);
}
int a;
while (m--) {
scanf("%d%d%d", &x, &y, &a);
Ret r = query(1, N, 1);
for (z = 0; z < 26; ++z) {
update(1, N, 1, -1);
}
if (a == 1) {
int now = x;
for (z = 0; z < 26; ++z) {
x = now;
y = now + r.ret[z] - 1;
update(1, N, 1, 1);
now += r.ret[z];
}
} else {
int now = x;
for (z = 25; z >= 0; --z) {
x = now;
y = now + r.ret[z] - 1;
update(1, N, 1, 1);
now += r.ret[z];
}
}
}
for (int i = 1; i <= n; ++i) {
x = i;
y = i;
Ret r = query(1, N, 1);
for (int j = 0; j < 26; ++j) {
if (r.ret[j]) putchar(j + 'a');
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 1e5 + 10;
const ll inf = 1e16 + 10;
const ll MOD = 1e9 + 7;
int n, m, d, c[N], pos[N];
int main() {
cin >> n >> m >> d;
for (int i = 1; i <= m; i++) cin >> c[i];
int last = 0;
for (int i = 1; i <= m; i++) {
pos[i] = last + d;
last = pos[i] + c[i] - 1;
}
if (last + d < n + 1) {
printf("NO\n");
return 0;
}
for (int i = 1; i <= m; i++) {
if (last <= n) break;
int reduce = last - n;
reduce = min(reduce, d - 1);
for (int j = i; j <= m; j++) {
pos[j] -= reduce;
}
last -= reduce;
}
printf("YES\n");
int prev = 0;
for (int i = 1; i <= m; i++) {
int here = pos[i] - prev - 1;
while (here--) printf("0 ");
here = c[i];
while (here--) printf("%d ", i);
prev = pos[i] + c[i] - 1;
}
int here = n - prev;
while (here--) printf("0 ");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> prime(5000005, 1);
void cal_primearray(long long n) {
for (int p = 2; p * p <= n; p++) {
if (prime[p] == 1) {
for (int i = p * 2; i <= n; i += p) prime[i] = 0;
}
}
}
long long modexpo(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long expo(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i += 6) {
if ((n % i == 0) || (n % (i + 2) == 0)) return false;
}
return true;
}
long long max_value(vector<long long> arr) {
long long m = 0;
for (int i = 0; i < arr.size(); i++) m = max(m, arr[i]);
return m;
}
void kmp(string second) {
vector<long long> v(second.length() + 1, 0);
long long cur = 0;
for (int j = 2; j < second.length(); j++) {
while (cur != 0 && second[cur] != second[j - 1]) cur = v[cur];
if (second[cur] == second[j - 1]) cur++;
v[j] = cur;
}
}
bool myfunc(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) return a.second < b.second;
return (a.first < b.first);
}
int main() {
int n;
cin >> n;
vector<int> arr(n, 0);
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 1; i < n; i++)
if (abs(arr[i] - arr[i - 1]) >= 2) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int N, K, T;
char G[200010];
int dop[22], FO[22][22];
bool has[22], IN[22];
int rem[22];
int dp[1 << 22];
void add(int a, int b, int mask) {
if ((mask & (1 << a)) || (mask & (1 << b))) return;
dp[mask] += FO[a][b];
dp[mask | (1 << a)] -= FO[a][b];
dp[mask | (1 << b)] -= FO[a][b];
dp[(mask | (1 << a)) | (1 << b)] += FO[a][b];
}
int main() {
int i, j, l, B = 0, CB;
scanf("%d%d%d", &N, &K, &T);
scanf("%s", &G);
for (i = 0; i < N; ++i) IN[G[i] -= 'A'] = true;
for (i = 0; i < K; ++i)
if (IN[i]) ++B;
for (i = 0; i < K; ++i) scanf("%d", &dop[i]);
for (i = 0; i < K; ++i)
for (j = 0; j < K; ++j) scanf("%d", &FO[i][j]);
for (i = N - 1; i >= 0; --i) {
for (j = 0; j < K; ++j)
if (has[j]) add(G[i], j, rem[j]);
for (j = 0; j < K; ++j)
if (j == G[i]) {
has[j] = true;
rem[j] = 0;
} else if (has[j])
rem[j] |= (1 << G[i]);
}
for (i = K - 1; i >= 0; --i)
for (j = 0; j < (1 << K); ++j)
if (j & (1 << i)) dp[j] += dp[j ^ (1 << i)];
int ans = 0;
for (i = 0; i < (1 << K); ++i) {
l = dp[i];
CB = 0;
for (j = 0; j < K; ++j)
if (i & (1 << j))
if (!IN[j])
break;
else {
l += dop[j];
++CB;
}
if (CB < B && j == K && l <= T) ++ans;
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return x;
}
const int LMAX = 12, RMAX = 18;
int n, m, q;
int L, R;
struct Bitset {
unsigned long long s[16];
void clear() {
for (int i = 0; i < 16; i++) s[i] = 0;
}
} S[1 << LMAX], T[1 << RMAX], msk[35], C;
bool operator<(const Bitset &x, const Bitset &y) {
for (int i = 0; i < 16; i++)
if (x.s[i] ^ y.s[i]) return x.s[i] < y.s[i];
return 0;
}
bool cmp1(int a, int b) {
Bitset &x = T[a], &y = T[b];
for (int i = 0; i < 16; i++)
if (x.s[i] ^ y.s[i]) return x.s[i] < y.s[i];
return 0;
}
Bitset operator^(const Bitset &x, const Bitset &y) {
static Bitset z;
*(z.s + 0) = *(x.s + 0) ^ *(y.s + 0);
*(z.s + 1) = *(x.s + 1) ^ *(y.s + 1);
*(z.s + 2) = *(x.s + 2) ^ *(y.s + 2);
*(z.s + 3) = *(x.s + 3) ^ *(y.s + 3);
*(z.s + 4) = *(x.s + 4) ^ *(y.s + 4);
*(z.s + 5) = *(x.s + 5) ^ *(y.s + 5);
*(z.s + 6) = *(x.s + 6) ^ *(y.s + 6);
*(z.s + 7) = *(x.s + 7) ^ *(y.s + 7);
*(z.s + 8) = *(x.s + 8) ^ *(y.s + 8);
*(z.s + 9) = *(x.s + 9) ^ *(y.s + 9);
*(z.s + 10) = *(x.s + 10) ^ *(y.s + 10);
*(z.s + 11) = *(x.s + 11) ^ *(y.s + 11);
*(z.s + 12) = *(x.s + 12) ^ *(y.s + 12);
*(z.s + 13) = *(x.s + 13) ^ *(y.s + 13);
*(z.s + 14) = *(x.s + 14) ^ *(y.s + 14);
*(z.s + 15) = *(x.s + 15) ^ *(y.s + 15);
return z;
}
void dfs1(int x, int O) {
if (x == L) return S[O] = C, void();
dfs1(x + 1, O);
C = C ^ msk[x + 1];
dfs1(x + 1, O | (1 << x));
C = C ^ msk[x + 1];
}
void dfs2(int x, int O) {
if (x == R) return T[O] = C, void();
dfs2(x + 1, O);
C = C ^ msk[x + L + 1];
dfs2(x + 1, O | (1 << x));
C = C ^ msk[x + L + 1];
}
int idtot = 1;
vector<pair<unsigned long long, int> > ch[(1 << RMAX) * 16 + 10];
vector<int> V;
int ans[(1 << RMAX) * 16 + 10];
void build(int x, int l, int r, int dep) {
if (dep == 16) {
ans[x] = 1e9;
for (int i = l; i <= r; i++) ans[x] = min(ans[x], __builtin_popcount(V[i]));
return;
}
for (int i = l, j; i <= r; i = j + 1) {
for (j = i; j + 1 <= r && T[V[j + 1]].s[dep] == T[V[j]].s[dep]; j++)
;
ch[x].push_back((pair<unsigned long long, int>){T[V[j]].s[dep], ++idtot});
build(idtot, i, j, dep + 1);
}
}
int work(int x, int dep) {
if (16 == dep) return ans[x];
int t = lower_bound(ch[x].begin(), ch[x].end(),
(pair<unsigned long long, int>){C.s[dep], 0}) -
ch[x].begin();
if (t >= ch[x].size() || ch[x][t].first != C.s[dep]) return 1e9;
return work(ch[x][t].second, dep + 1);
}
int main() {
n = read(), m = read(), q = read();
R = min(RMAX, m);
L = m - R;
for (int i = 1; i <= m; i++) {
int t = read();
while (t--) {
int x = read(), u = x >> 6, v = x & 63;
msk[i].s[u] |= 1ULL << v;
}
}
dfs1(0, 0);
dfs2(0, 0);
V.resize(1 << R);
for (int i = 0; i < 1 << R; i++) V[i] = i;
sort(V.begin(), V.end(), cmp1);
build(1, 0, V.size() - 1, 0);
while (q--) {
C.clear();
int t = read();
while (t--) {
int x = read(), u = x >> 6, v = x & 63;
C.s[u] |= 1ULL << v;
}
int res = 1e9;
for (int O = 0; O < 1 << L; O++) {
C = C ^ S[O];
res = min(res, __builtin_popcount(O) + work(1, 0));
C = C ^ S[O];
}
if (res == 1e9)
puts("-1");
else
printf("%d\n", res);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > edge[1 << 20];
map<long long, long long> mp[1 << 20];
long long dist[1 << 20];
bool visit[1 << 20];
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b, c;
scanf("%I64d %I64d %I64d", &a, &b, &c);
edge[a].push_back(make_pair(b, c));
edge[b].push_back(make_pair(a, c));
}
for (long long i = 0; i < n; i++) {
long long k;
scanf("%I64d", &k);
vector<long long> temp;
for (long long i = 0; i < k; i++) {
long long a;
scanf("%I64d", &a);
temp.push_back(a);
}
for (long long i1 = 0; i1 < k; i1++) {
long long j = i1;
while (i1 + 1 < k and temp[i1] + 1 == temp[i1 + 1]) {
i1++;
}
for (; j <= i1; j++) {
mp[i + 1][temp[j]] = temp[i1] + 1;
}
}
}
for (long long i = 1; i <= n; i++) {
dist[i] = INT_MAX;
}
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
q.push(make_pair(mp[1][0], 1));
dist[1] = mp[1][0];
while (q.size()) {
pair<long long, long long> p = q.top();
q.pop();
long long v = p.second, d = p.first;
if (visit[v]) {
if (v == n) {
break;
}
continue;
}
visit[v] = 1;
long long ss = d;
if (mp[v].count(d)) {
ss = mp[v][d];
}
for (long long i = 0; i < edge[v].size(); i++) {
long long u = edge[v][i].first, d1 = edge[v][i].second;
if (dist[u] == INT_MAX) {
dist[u] = d1 + ss;
q.push(make_pair(dist[u], u));
} else if (dist[u] > ss + d1) {
dist[u] = d1 + ss;
q.push(make_pair(dist[u], u));
}
}
}
if (dist[n] == INT_MAX) {
cout << "-1";
} else {
cout << dist[n];
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void display(string s, int rock, int paper, int scissors) {
int len = s.size();
char c[len + 1];
memset(c, 0, sizeof(char) * (len + 1));
for (int i = 0; i < len; ++i) {
if (s[i] == 'R' && paper > 0)
--paper, c[i] = 'P';
else if (s[i] == 'P' && scissors > 0)
--scissors, c[i] = 'S';
else if (s[i] == 'S' && rock > 0)
--rock, c[i] = 'R';
}
for (int i = 0; i < len; ++i) {
if (c[i] == 0) {
if (paper > 0)
c[i] = 'P', --paper;
else if (rock > 0)
c[i] = 'R', --rock;
else if (scissors > 0)
c[i] = 'S', --scissors;
}
}
cout << c << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n, rock, paper, scissors;
cin >> n >> rock >> paper >> scissors;
string s;
cin >> s;
int r = 0, p = 0, ss = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'R')
r++;
else if (s[i] == 'P')
p++;
else
ss++;
}
int ans = std::min(r, paper) + std::min(p, scissors) + std::min(ss, rock);
if (ans >= (n + 1) / 2)
cout << "YES\n", display(s, rock, paper, scissors);
else
cout << "NO\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long powN(long long a, long long p) {
if (p == 0) return 1;
long long z = powN(a, p / 2);
z = (z * z) % 998244353;
if (p % 2) z = (z * a) % 998244353;
return z;
}
long long modinverse(long long n, long long p) { return (powN(n, p - 2)); }
long long ncr(long long n, long long r) {
long long p = 998244353;
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return ((fac[n] * (modinverse(fac[r], p) % p)) % p *
modinverse(fac[n - r], p) % p) %
p;
}
void bfs(int s, vector<int> adj[], int n, int p[]) {
p[s] = s;
queue<int> q;
q.push(s);
vector<bool> visited(n + 1, false);
visited[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < int((adj[u]).size()); ++i) {
int v = adj[u][i];
if (!visited[v]) {
q.push(v);
visited[v] = true;
p[v] = u;
}
}
}
}
int main() {
int n;
cin >> n;
int A[n];
long long sum = 0;
int maxi = -1;
int marks[n];
for (int i = 0; i < n; ++i) {
cin >> A[i];
maxi = max(A[i], maxi);
marks[i] = maxi + 1;
}
for (int i = n - 2; i >= 0; --i) {
if (marks[i + 1] - marks[i] > 1) marks[i] = marks[i + 1] - 1;
}
for (int i = 0; i < n; ++i) {
sum = sum + marks[i] - A[i];
}
cout << sum - n << endl;
}
| 4 |
#include <bits/stdc++.h>
const long double pi = 3.14159265359;
const long double Exp = 2.71828182846;
using namespace std;
void Prepere_streams() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
long long c[1001][1001];
int main() {
long long n;
cin >> n;
long long f = 1;
c[1][0] = c[1][1] = 1;
for (int i = 2; i <= n + 10; ++i) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; ++j) c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
f *= i;
}
cout << c[n + 4][5] * c[n + 2][3];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = (long long)1000000007;
long long gcd(long long a, long long b) { return (!b ? a : gcd(b, a % b)); }
int gcd(int a, int b) { return (!b ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int pc(long long x) { return __builtin_popcount(x); }
int lsf(long long x) { return x ^ (x & (x - 1)); }
void prv(vector<int> vec) {
for (auto v : vec) cout << v << " ";
}
long long exGcd(long long a, long long b, long long &x, long long &y) {
if (a < 0) {
long long r = exGcd(-a, b, x, y);
x *= -1;
return r;
}
if (b < 0) {
long long r = exGcd(a, -b, x, y);
y *= -1;
return r;
}
if (!b) {
x = 1, y = 0;
return a;
}
long long prevX, prevY;
long long gcd = exGcd(b, a % b, prevX, prevY);
x = prevY;
y = prevX - a / b * prevY;
return gcd;
}
bool cmp(const pair<char, int> &a, const pair<char, int> &b) {
return (a != b ? a < b : a.second < b.second);
}
bool sameParity(long long a, long long b) { return (a % 2 == b % 2); }
vector<int> ModMulInvRange(int p) {
vector<int> inv(p - 1, 1);
for (int i = 2; i < p; ++i) inv[i] = (p - (p / i) * inv[p % i] % p) % p;
return inv;
}
long long pow(long long a, long long k, long long m) {
if (!k) return 1;
long long res = pow(a, k >> 1, m);
res = (res * res) % m;
if (k & 1) res = (res * a) % m;
return res % m;
}
long long phi(long long m) {
int count = 0;
long long p, res = 1, nn = m;
while (!(nn % 2)) ++count, nn >>= 1;
if (count) res *= (1 << (count - 1));
for (long long i = 3; i * i <= m; i += 2) {
p = 1;
while (!(nn % i)) nn /= i, p *= i;
if (p != 1) res *= (p / i * (i - 1));
}
if (nn != 1) res *= (nn - 1);
return res;
}
long long fact(long long n, long long m) {
long long res = 1;
for (int i = 2; i <= n; ++i) res *= i, res %= m;
return res;
}
long long modMulInv(long long a, long long m) { return pow(a, m - 2, m); }
long long nCr(long long n, long long r, long long m) {
return (fact(n, m) * modMulInv((fact(n - r, m) * fact(r, m)) % m, MOD)) % m;
}
void tst(bool bol) { cout << (bol ? "YES" : "NO") << '\n'; }
void tst(bool bol1, bool bol2) {
cout << (bol1 && bol2 ? "YES" : "NO") << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, n, val, val1, val2, v, v1, v2, a, b, aa, bb, c, d;
bool ok, ok1, ok2, done;
vector<int> vec;
cin >> t;
while (t--) {
cin >> n >> a >> b >> c >> d;
int x = a - b, y = a + b;
int s = n * x, l = n * y;
int x1 = c - d, x2 = c + d;
if (x1 > l || x2 < s)
cout << "No";
else
cout << "Yes";
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const int M = 1000000007;
char mm[MAXN][MAXN];
int tab[256];
int main() {
int m, n;
long long ans = 1;
cin >> m >> n;
for (int i = 0; i < m; i++) scanf("%s", mm[i]);
for (int j = 0; j < n; j++) {
memset(tab, 0, sizeof(tab));
for (int i = 0; i < m; i++) tab[mm[i][j]] = 1;
int cnt = 0;
for (int i = 0; i < 256; i++)
if (tab[i]) cnt++;
ans *= cnt;
ans %= M;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 7;
bool square[N] = {};
void precalc() {
for (int i = 1; i <= 1000; i++) square[i * i] = true;
}
int gcd(int a, int b) {
if (a < b) swap(a, b);
while (b != 0) {
int x = a % b;
a = b;
b = x;
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
precalc();
int a, b;
cin >> a >> b;
for (int i = 1; i < a; i++) {
int x = i;
int y = (int)sqrt(a * a - x * x);
if (square[a * a - x * x]) {
int d = gcd(x, y);
x /= d;
y /= d;
int dist = (int)sqrt(x * x + y * y);
if (b % dist == 0) {
int x1 = -y * b / dist;
int y1 = x * b / dist;
if (x1 != x * d && y1 != y * d) {
cout << "YES\n"
<< "0 0\n"
<< x * d << ' ' << y * d << endl
<< x1 << ' ' << y1;
return 0;
}
}
}
}
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
void solve() {
long long n, m, k;
cin >> n >> m >> k;
vector<pair<long long, long long>> graph[n];
long long d[n][n];
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) d[i][j] = ((i == j) ? 0 : INT_MAX);
for (long long i = 0; i < m; i++) {
long long a, b, w;
cin >> a >> b >> w;
a--;
b--;
d[a][b] = d[b][a] = w;
graph[a].push_back({b, w});
graph[b].push_back({a, w});
}
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++)
for (long long k = 0; k < n; k++)
d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
vector<pair<long long, long long>> query(k);
for (auto &[a, b] : query) {
cin >> a >> b;
a--;
b--;
}
long long ans = LONG_MAX;
for (long long src = 0; src < n; src++) {
for (auto [dst, weight] : graph[src]) {
long long curr = 0;
for (auto [a, b] : query) {
curr += min(d[a][b], min(d[a][src] + d[b][dst], d[a][dst] + d[b][src]));
}
ans = min(ans, curr);
}
}
cout << ans << "\n";
}
int main() { solve(); }
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int numbers[n];
long long result = 0;
int minusesAmount = 0;
int zerosAmount = 0;
for (int i = 0; i < n; i++) {
cin >> numbers[i];
if (numbers[i] != 0) {
result += abs(numbers[i]) - 1;
if (numbers[i] < 0) minusesAmount++;
} else {
zerosAmount++;
}
}
if (minusesAmount % 2 == 1) {
if (zerosAmount > 0) {
zerosAmount--;
result++;
} else
result += 2;
}
if (zerosAmount > 0) result += zerosAmount;
cout << result << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int s, n, m, t, x, y;
vector<int> ord;
vector<vector<int>> g;
bool vis[200010];
void dfs(int c) {
vis[c] = true;
for (auto &v : g[c]) {
if (!vis[v]) dfs(v);
}
ord.push_back(c);
}
int main() {
std::istream::sync_with_stdio(false);
cin >> s;
while (s--) {
cin >> n >> m;
vector<pair<int, int>> edges;
g = vector<vector<int>>(n + 1);
for (int i = 0; i < m; i++) {
cin >> t >> x >> y;
if (t == 1) {
g[x].push_back(y);
}
edges.emplace_back(x, y);
}
ord.clear();
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
vector<int> pos(n + 1);
reverse(ord.begin(), ord.end());
for (int i = 0; i < n; i++) {
pos[ord[i]] = i;
}
bool flag = false;
for (int i = 1; i <= n; i++) {
for (auto &v : g[i]) {
if (pos[i] > pos[v]) flag = true;
}
}
if (flag) {
cout << "NO" << endl;
continue;
} else {
cout << "YES" << endl;
for (auto &v : edges) {
if (pos[v.first] < pos[v.second]) {
cout << v.first << " " << v.second << endl;
} else {
cout << v.second << " " << v.first << endl;
}
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int> > v(1000001);
for (int i = 0; i < n; ++i) {
int num;
cin >> num;
v[num].first++;
v[num].second = i;
}
int mx = 0;
int ans = 0;
int time = 0;
for (int i = 0; i < 1000001; ++i) {
if (v[i].first > mx || (v[i].first == mx && v[i].second < time))
mx = v[i].first, ans = i, time = v[i].second;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int sortindex[20][500010];
pair<pair<int, int>, int> sa[500010];
int lcp[500010];
int n;
char s[500010];
vector<int> pos_string[2 * 500010];
vector<int> pos_sa[2 * 500010];
int pre[500010];
void buildSA() {
int i, j;
for (i = 0; i < n; ++i) sortindex[0][i] = s[i] - '(';
for (i = 0; i < n; ++i) sa[i].second = i;
for (i = 1; (1 << (i - 1)) < n; ++i) {
for (j = 0; j < n; ++j) {
sa[j].first.first = sortindex[i - 1][sa[j].second];
if (sa[j].second + (1 << (i - 1)) < n)
sa[j].first.second = sortindex[i - 1][sa[j].second + (1 << (i - 1))];
else
sa[j].first.second = -1;
}
sort(sa, sa + n);
int cnt = 0;
sortindex[i][sa[0].second] = 0;
for (j = 1; j < n; ++j) {
if (sa[j].first == sa[j - 1].first)
sortindex[i][sa[j].second] = sortindex[i][sa[j - 1].second];
else
sortindex[i][sa[j].second] = ++cnt;
}
}
}
int findlcp(int x, int y) {
int i;
int ret = 0;
for (i = 0; (1 << (i - 1)) < n; ++i)
;
--i;
for (; i >= 0; --i) {
if (sortindex[i][x] == sortindex[i][y]) {
ret += (1 << i);
x += (1 << i);
y += (1 << i);
if (x >= n || y >= n) break;
}
}
return ret;
}
void buildlcp() {
int i;
for (i = 1; i < n; ++i) lcp[i] = findlcp(sa[i - 1].second, sa[i].second);
}
int bit[2][500010];
inline void update(int i, int val, bool f) {
while (i <= n) {
bit[f][i] += val;
i = i + (i & (-i));
}
}
inline int query(int i, bool f) {
int ret = 0;
while (i) {
ret += bit[f][i];
i = i - (i & (-i));
}
return ret;
}
inline int query(int i, int j, bool f) {
if (j < i) return 0;
++i;
++j;
return query(j, f) - query(i - 1, f);
}
int main() {
int i;
scanf("%d", &n);
scanf("%s", &s);
buildSA();
buildlcp();
lcp[0] = 0;
pre[0] = 0;
for (i = 1; i <= n; ++i) {
pre[i] = pre[i - 1];
if (s[i - 1] == '(')
pre[i]++;
else
pre[i]--;
pos_string[pre[i] + n].push_back(i - 1);
}
for (i = 0; i < n; ++i) pos_sa[pre[sa[i].second] + n].push_back(i);
memset(bit[0], 0, sizeof(bit[0]));
memset(bit[1], 0, sizeof(bit[1]));
long long ans = 0;
for (i = 0; i < 2 * n; ++i) {
for (auto j : pos_string[i]) update(j + 1, 1, 0);
for (auto j : pos_sa[i]) {
int lo = sa[j].second, hi = n - 1, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (query(sa[j].second, mid, 1))
hi = mid;
else
lo = mid + 1;
}
if (query(sa[j].second, lo, 1)) --lo;
hi = min(lo, n - 1);
lo = sa[j].second + lcp[j];
ans = ans + query(lo, hi, 0);
}
for (auto j : pos_string[i]) {
update(j + 1, -1, 0);
update(j + 1, 1, 1);
}
}
printf("%lld\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans, k, l[5001], r[5001], q[5001];
class Candy {
public:
long long b, e;
friend bool operator<(const Candy t1, const Candy t2) {
if (t1.b == t2.b) return t1.e < t2.e;
return t1.b < t2.b;
}
} candy[20005];
long long Read() {
long long k = 0, tmp = 1;
char c = getchar();
while (c > '9' or c < '0') {
if (c == '-') tmp = -1;
c = getchar();
}
while (c <= '9' and c >= '0') {
k = (k << 1) + (k << 3) + (c ^ 48);
c = getchar();
}
return k * tmp;
}
void Work();
int main() { Work(); }
void Work() {
n = Read(), m = Read();
for (int i = 1; i <= m; i++) {
candy[i].b = Read(), candy[i].e = Read();
}
sort(candy + 1, candy + 1 + m);
for (int i = 1; i <= n; i++) {
int j;
for (j = r[i - 1] + 1; j <= m && candy[j].b == i; j++)
;
j--;
l[i] = r[i - 1] + 1;
r[i] = j;
}
for (int i = 1; i <= n; i++) {
if (l[i] > r[i]) {
q[i] = -1;
continue;
}
q[i] = 2147483647ll * 2147483647, k = r[i] - l[i];
for (int j = l[i]; j <= r[i]; j++) {
q[i] = min(q[i], k * n + (candy[j].e + n - i) % n);
}
}
for (int i = 1; i <= n; i++) {
ans = 0;
for (int j = 1; j <= n; j++) {
if (q[j] != -1) ans = max(ans, q[j] + (j + n - i) % n);
}
cout << ans << ' ';
}
}
| 5 |
#include <bits/stdc++.h>
const int MX = 1e4 + 23;
int Pcnt;
struct POINT {
int type, x, y, down;
bool operator<(const POINT& B) const { return y < B.y; }
} P[MX];
int Hcnt;
struct Hseg {
int l, r, y;
bool operator<(const Hseg& B) const { return y < B.y; }
} H[MX];
struct BIT {
int data[MX];
void clear() { memset(data, 0, sizeof data); }
void add(int x, int v) {
while (x < MX) data[x] += v, x += x & -x;
}
int sum(int x) {
int s = 0;
while (x > 0) s += data[x], x -= x & -x;
return s;
}
} C;
int main() {
int n;
std::cin >> n;
for (int i = 1, x1, y1, x2, y2; i <= n; ++i) {
std::cin >> x1 >> y1 >> x2 >> y2;
x1 += 5001, x2 += 5001;
if (x1 > x2) std::swap(x1, x2);
if (y1 > y2) std::swap(y1, y2);
if (x1 == x2) {
P[++Pcnt] = (POINT){1, x1, y1, y1};
P[++Pcnt] = (POINT){-1, x1, y2 + 1, y1};
} else {
H[++Hcnt] = (Hseg){x1, x2, y1};
}
}
long long Ans = 0;
std::sort(H + 1, H + 1 + Hcnt);
std::sort(P + 1, P + 1 + Pcnt);
for (int i = 1; i <= Hcnt; ++i) {
C.clear();
int k = 1;
for (int j = i + 1; j <= Hcnt; ++j) {
if (H[j].l > H[i].r || H[j].r < H[i].l) continue;
while (k <= Pcnt && P[k].y <= H[j].y) {
if (H[i].l <= P[k].x && P[k].x <= H[i].r && P[k].down <= H[i].y) {
C.add(P[k].x, P[k].type);
}
++k;
}
int l = std::max(H[i].l, H[j].l);
int r = std::min(H[i].r, H[j].r);
int s = C.sum(r) - C.sum(l - 1);
Ans += s * (s - 1) / 2;
}
}
std::cout << Ans << std::endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1003;
bool played[N][N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<pair<int, int>> res(n * k);
int sz = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0, cnt = 0; cnt < k && j < n; ++j) {
if (i != j && !played[i][j]) {
res[sz++] = {i + 1, j + 1};
played[i][j] = played[j][i] = true;
++cnt;
}
}
}
if (sz != n * k) {
puts("-1");
} else {
printf("%d\n", n * k);
for (int i = 0; i < (int)res.size(); ++i) {
printf("%d %d\n", res[i].first, res[i].second);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int c = 200002;
int w, kezd[c], veg[c], t[c];
long long sum, n, k;
vector<pair<long double, int> > sz;
long double x[c], y[c], lo = 0, hi = 2e4, mid, eps = 1e-7;
void pb(long double a, long double b, int i) {
if (b < 0) {
a = c - a;
}
sz.push_back({a, i});
}
int lsb(int a) { return (a & (-a)); }
void add(int a, int b) {
while (a < c) {
t[a] += b;
a += lsb(a);
}
}
int ask(int a) {
int sum = 0;
while (a) {
sum += t[a];
a -= lsb(a);
}
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
k = n * (n - 1) / 2 - k;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
while (hi - lo > eps) {
mid = (hi + lo) / 2;
sum = 0;
sz.clear();
for (int i = 1; i <= n; i++) {
long double dist = sqrt((x[i] * x[i] + y[i] * y[i]));
if (dist > mid) {
long double r = (sqrt(dist * dist - mid * mid)),
p = (mid * mid) / (mid * mid + r * r),
ert = sqrt(mid * mid / dist / dist - p * p);
long double xx = p * x[i], yy = p * y[i], v1 = ert * y[i],
v2 = ert * x[i];
pb(xx + v1, yy - v2, i);
pb(xx - v1, yy + v2, i);
}
}
for (int i = 1; i <= n; i++) {
kezd[i] = veg[i] = 0;
}
sort(sz.begin(), sz.end());
int si = sz.size();
for (int i = 0; i < si; i++) {
int id = sz[i].second;
if (!kezd[id]) {
kezd[id] = i + 1;
} else {
veg[id] = i + 1;
}
}
for (int i = 0; i < si; i++) {
int id = sz[i].second;
if (kezd[id] == i + 1) {
sum += ask(veg[id]);
add(veg[id], 1);
} else {
add(veg[id], -1);
}
}
if (sum > k) {
lo = mid;
} else {
hi = mid;
}
}
cout.precision(10);
cout << lo << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char mini[110], maxi[110];
int main() {
int m, s, curr;
scanf("%d%d", &m, &s);
if (m == 1 && s == 0) {
printf("0 0");
return 0;
}
if (s == 0 || s > (9 * m)) {
printf("-1 -1");
return 0;
}
curr = 0;
for (int i = 0; i < m; i++) {
mini[i] = max(s - curr - ((m - 1 - i) * 9), i == 0 ? 1 : 0) + '0';
curr += mini[i] - '0';
}
mini[m] = '\0';
curr = 0;
for (int i = 0; i < m; i++) {
maxi[i] = min(s - curr - ((m - 1 - i) * 0), 9) + '0';
curr += maxi[i] - '0';
}
maxi[m] = '\0';
printf("%s %s", mini, maxi);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
const long long maxn = 2007, maxm = 4007, inf = 0x3f3f3f3f3f3f3f3f;
long long n, m, s, t, maxflow;
long long dep[maxn], cur[maxn], de[maxn];
long long tot = 1, head[maxn];
struct edge {
long long to, nxt, w;
} e[maxm << 1];
inline void adde(long long u, long long v, long long w) {
e[++tot] = (edge){v, head[u], w};
head[u] = tot;
}
inline void add(long long u, long long v, long long w) {
adde(u, v, w);
adde(v, u, 0);
}
inline void ins(long long u, long long v, long long l, long long r) {
add(u, v, r - l), de[u] -= l, de[v] += l;
}
bool bfs(long long s, long long t) {
queue<long long> q;
memcpy(cur, head, sizeof cur);
memset(dep, 63, sizeof dep);
dep[s] = 0;
q.push(s);
while (!q.empty()) {
long long u = q.front();
q.pop();
for (long long i = head[u]; i; i = e[i].nxt) {
long long v = e[i].to;
if (dep[v] == inf && e[i].w) {
dep[v] = dep[u] + 1;
q.push(v);
}
}
}
return dep[t] < inf;
}
long long dfs(long long u, long long t, long long minn) {
if (!minn || u == t) return minn;
long long res = 0;
for (long long i = cur[u]; i; i = e[i].nxt) {
long long v = e[i].to;
cur[u] = i;
if (dep[v] != dep[u] + 1) continue;
long long flow = dfs(v, t, min(minn, e[i].w));
if (!flow) continue;
res += flow, minn -= flow;
e[i].w -= flow, e[i ^ 1].w += flow;
if (!minn) break;
}
if (!res) dep[u] = 0;
return res;
}
inline long long dinic(long long s, long long t) {
long long maxflow = 0;
while (bfs(s, t)) maxflow += dfs(s, t, inf);
return maxflow;
}
long long a[maxn], b[maxn], c[maxn], d[maxn], uu[maxn], vv[maxn],
lim = 100000000;
map<long long, long long> mp;
long long func(long long v) {
if (mp.count(v)) return mp[v];
for (register long long i = (1); i <= (n + 2); ++i) head[i] = de[i] = 0;
s = n + 1, t = n + 2;
tot = 1;
for (register long long i = (1); i <= (m); ++i) {
long long l = a[i] * v + b[i] * lim, r = c[i] * v + d[i] * lim;
ins(uu[i], vv[i], l, r);
}
long long res = 0;
for (register long long i = (1); i <= (n); ++i)
if (de[i] > 0)
add(s, i, de[i]), res += de[i];
else
add(i, t, -de[i]);
return mp[v] = res - dinic(s, t);
}
signed main() {
n = read(), m = read();
for (register long long i = (1); i <= (m); ++i) {
uu[i] = read(), vv[i] = read();
a[i] = read(), b[i] = read(), c[i] = read(), d[i] = read();
}
func(75000004);
long long l = 0, r = lim;
while (r - l >= 5) {
long long m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
if (func(m1) < func(m2))
r = m2;
else
l = m1;
}
pair<long long, long long> mg = make_pair(inf, inf);
for (register long long i = (l); i <= (r); ++i)
mg = min(mg, make_pair(func(i), i));
if (mg.first) {
puts("0");
return 0;
}
l = mg.second + 1, r = lim;
long long resl = mg.second, resr = mg.second;
while (l <= r) {
long long mid = l + r >> 1;
if (!func(mid))
resr = mid, l = mid + 1;
else
r = mid - 1;
}
l = 0, r = mg.second - 1;
while (l <= r) {
long long mid = l + r >> 1;
if (!func(mid))
resl = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%.8lf", 1.0 * (resr - resl) / lim);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
vector<long long int> ans;
long long int n, i, cnt = 0;
cin >> n;
for (i = 0; i <= min(90ll, n); i++) {
long long int x = n - i;
long long int s = 0;
while (x > 0) {
s += x % 10;
x /= 10;
}
if (s == i) {
ans.push_back(n - s);
cnt++;
}
}
cout << cnt << endl;
sort(ans.begin(), ans.end());
for (i = 0; i < ans.size(); i++) cout << ans[i] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mxN = 1e6;
char line[mxN];
int main() {
ios_base::sync_with_stdio(false);
cin.getline(line, 1e6);
vector<string> w;
vector<char> s;
for (long long i = 0; i < 1e5 + 500; i++) {
if (line[i] == '\0') {
string t = "";
for (auto it : s) {
t += it;
}
w.push_back(t);
break;
}
if (line[i] == ' ') {
string t = "";
for (auto it : s) {
t += it;
}
w.push_back(t);
s.erase(s.begin(), s.end());
continue;
}
s.push_back(line[i]);
}
long long cnt = w.size();
if (cnt == 1) {
long long n = w[0].size();
string str1 = ".", str2 = ".", str3 = ".", str4 = ".";
if (n >= 4) str1 = w[0].substr(n - 4, 4);
if (n >= 5) str2 = w[0].substr(n - 5, 5);
if (n >= 3) str3 = w[0].substr(n - 3, 3);
if (n >= 6) str4 = w[0].substr(n - 6, 6);
if (str1 == "etra" || str1 == "lios" || str2 == "liala" || str3 == "etr" ||
str4 == "inites" || str4 == "initis")
cout << "YES";
else
cout << "NO";
return 0;
}
bool masculine = false, feminine = false, ok = true;
long long startadj = -1, endadj = -1, startnoun = -1, endnoun = -1,
startverb = 1e6, endverb = 1e6;
for (long long i = 0; i < cnt; i++) {
long long n = w[i].length();
if (n < 3) {
ok = false;
break;
}
string str1 = ".", str2 = ".", str3 = ".", str4 = ".";
bool done = false;
if (n >= 4) str1 = w[i].substr(n - 4, 4);
if (n >= 5) str2 = w[i].substr(n - 5, 5);
if (n >= 3) str3 = w[i].substr(n - 3, 3);
if (n >= 6) str4 = w[i].substr(n - 6, 6);
if (str1 != "." && str1 == "lios") {
if (startadj == -1) {
startadj = i;
}
endadj = i;
masculine = true;
done = true;
}
if (str1 != "." && str1 == "etra") {
if (startnoun == -1) {
startnoun = i;
}
endnoun = i;
feminine = true;
done = true;
}
if (str2 != "." && str2 == "liala") {
if (startadj == -1) {
startadj = i;
}
endadj = i;
feminine = true;
done = true;
}
if (str4 != "." && str4 == "inites") {
if (startverb == 1e6) {
startverb = i;
}
endverb = i;
done = true;
feminine = true;
}
if (str3 != "." && str3 == "etr") {
if (startnoun == -1) {
startnoun = i;
}
endnoun = i;
done = true;
masculine = true;
}
if (str4 != "." && str4 == "initis") {
if (startverb == 1e6) {
startverb = i;
}
endverb = i;
done = true;
masculine = true;
}
if (!done) {
ok = false;
break;
}
}
if (!ok) {
cout << "NO";
} else {
if ((masculine == true && feminine == true) ||
(masculine == false && feminine == false))
cout << "NO";
else {
if (startnoun == endnoun && startnoun != -1 && startnoun > endadj &&
endnoun < startverb) {
cout << "YES";
} else {
cout << "NO";
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<string, multiset<int> > ma;
string s;
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> s >> k;
ma[s].insert(k);
}
long long ans = 0;
int p = 0;
while (ma.size() > 0) {
auto t1 = *ma.begin();
ma.erase(ma.begin());
s = t1.first;
reverse(s.begin(), s.end());
if (ma.find(s) == ma.end()) {
if (s == t1.first) {
while (t1.second.size() > 1) {
n = *((t1.second).rbegin());
t1.second.erase(t1.second.find(n));
k = *((t1.second).rbegin());
t1.second.erase(t1.second.find(k));
if (n + k > 0) {
ans += n + k;
if (n + k < n) {
p = max(p, -k);
}
} else {
t1.second.insert(n);
t1.second.insert(k);
break;
}
}
if (t1.second.size() > 0) {
n = *((t1.second).rbegin());
t1.second.erase(t1.second.find(n));
p = max(p, n);
}
}
} else {
auto t2 = *ma.find(s);
ma.erase(ma.find(s));
while (t1.second.size() > 0 && t2.second.size() > 0) {
n = *((t1.second).rbegin());
t1.second.erase(t1.second.find(n));
k = *((t2.second).rbegin());
t2.second.erase(t2.second.find(k));
if (n + k > 0) {
ans += n + k;
} else {
break;
}
}
}
}
cout << ans + p;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 6)
cout << -1 << endl;
else {
cout << "1 2" << endl;
cout << "2 3" << endl;
cout << "2 4" << endl;
for (int i = 5; i <= n; i++) cout << 3 << " " << i << endl;
}
for (int i = 2; i <= n; i++) {
cout << 1 << " " << i << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<int> > G;
vector<long long> sum;
vector<vector<long long> > M;
vector<vector<vector<long long> > > D;
vector<vector<long long> > M2;
void dfs(int u) {
sum[u] = 1;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (sum[v] == -1) {
dfs(v);
sum[u] += sum[v];
}
}
}
long long dp1(int p, int qtt, vector<int> &adj) {
if (p == adj.size()) return (qtt == 0) ? 1 : 0;
long long &ans = M[p][qtt];
if (ans == -1) {
ans = dp1(p + 1, qtt, adj);
if (qtt > 0)
ans += dp1(p + 1, qtt - 1, adj) * sum[adj[p]] * (sum[adj[p]] - 1);
}
return ans;
}
long long dp2(int u, int b) {
long long &ans = M2[u][b];
if (ans == -1) {
if (b == 0) {
ans = 0;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (sum[v] < sum[u]) ans += sum[v] * (sum[v] - 1) / 2;
}
} else
ans = 1;
long long S = 0;
for (int i = 0; i < G[u].size(); ++i)
if (sum[G[u][i]] < sum[u]) S += sum[G[u][i]] * (sum[G[u][i]] - 1);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (sum[v] < sum[u]) {
ans += dp2(v, b);
if (b == 0) ans += dp2(v, 1) * (S - sum[v] * (sum[v] - 1)) / 2;
}
}
}
return ans;
}
long long dp3(int p, int a, int b, vector<int> &adj) {
if (p == adj.size()) return (a == 0 and b == 0) ? 1 : 0;
long long &ans = D[p][a][b];
if (ans == -1) {
ans = dp3(p + 1, a, b, adj);
if (a > 0) ans += sum[adj[p]] * dp3(p + 1, a - 1, b, adj);
if (b > 0)
ans += sum[adj[p]] * (sum[adj[p]] - 1) * dp3(p + 1, a, b - 1, adj);
}
return ans;
}
long long solve(int u) {
long long res = 0;
vector<int> adj;
for (int i = 0; i < G[u].size(); ++i)
if (sum[G[u][i]] < sum[u]) adj.push_back(G[u][i]);
for (int i = 0; i < adj.size(); ++i) res += solve(adj[i]);
if (adj.size() >= 2) {
M = vector<vector<long long> >(adj.size(), vector<long long>(3, -1));
res += dp1(0, 2, adj) / 4;
}
long long S = 0;
for (int i = 0; i < adj.size(); ++i) S += sum[adj[i]] * (sum[adj[i]] - 1);
for (int i = 0; i < adj.size(); ++i) {
res += dp2(adj[i], 1) * (S - sum[adj[i]] * (sum[adj[i]] - 1)) / 2;
res += dp2(adj[i], 0);
}
if (adj.size() >= 3) {
D = vector<vector<vector<long long> > >(
adj.size(), vector<vector<long long> >(3, vector<long long>(2, -1)));
res += dp3(0, 2, 1, adj) / 2;
}
S = 0;
for (int i = 0; i < adj.size(); ++i) S += sum[adj[i]];
if (adj.size() >= 2) {
for (int i = 0; i < adj.size(); ++i)
res += (S - sum[adj[i]]) * dp2(adj[i], 0);
}
return res;
}
int main() {
cin >> n;
G = vector<vector<int> >(n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
G[u].push_back(v);
G[v].push_back(u);
}
sum = vector<long long>(n, -1);
dfs(0);
M2 = vector<vector<long long> >(n, vector<long long>(2, -1));
cout << 2 * solve(0) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int row[maxn], col[maxn];
int ans[maxn][maxn];
int main() {
int k, c, h;
cin >> k >> c >> h;
for (int i = 1; i <= c; i++) cin >> col[i];
for (int i = 1; i <= k; i++) cin >> row[i];
for (int i = 1; i <= k; i++)
for (int j = 1; j <= c; j++) {
cin >> ans[i][j];
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= c; j++) {
if (ans[i][j] == 1) ans[i][j] = row[i];
}
}
for (int j = 1; j <= c; j++) {
int flag = 1;
for (int i = 1; i <= k; i++) {
if (ans[i][j] > col[j]) ans[i][j] = col[j];
if (col[j] > ans[i][j] && ans[i][j] != 0 && flag == 1) {
if (row[i] >= col[j]) {
flag = 0;
ans[i][j] = col[j];
}
}
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= c; j++) printf("%d ", ans[i][j]);
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
int a[150];
int gcd(int x, int y);
int main() {
int n;
cin >> n;
int Max = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
Max = max(a[i], Max);
}
int ans = 0;
int Min = a[0];
for (int i = 0; i < n; i++) {
Min = gcd(Min, a[i]);
}
ans = Max / Min - n;
if (ans % 2 == 0)
cout << "Bob" << endl;
else
cout << "Alice" << endl;
return 0;
}
int gcd(int x, int y) {
int tem;
if (x < y) {
tem = x;
x = y;
y = tem;
}
if (y == 0)
return x;
else
return gcd(y, x % y);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
struct edge {
int to, next;
} e[2 * maxn * maxn];
int head[maxn * 2], np;
void adde(int u, int v) {
e[++np] = (edge){v, head[u]};
head[u] = np;
e[++np] = (edge){u, head[v]};
head[v] = np;
}
int n, m, d[maxn * 2];
void bfs() {
queue<int> q;
memset(d, 1, sizeof(d));
q.push(1);
d[1] = 0;
while (!q.empty()) {
int i = q.front();
q.pop();
for (int p = head[i]; p; p = e[p].next) {
int j = e[p].to;
if (d[i] + 1 < d[j]) d[j] = d[i] + 1, q.push(j);
}
}
}
int main() {
char ch;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> ch;
if (ch == '#') adde(i, j + n);
}
bfs();
printf("%d\n", d[n] > maxn * maxn ? -1 : d[n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (a < b) swap(a, b);
return gcd(a % b, b);
}
long long gcdextended(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1, gcd = gcdextended(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
}
long long modinverse(long long a, long long m) {
long long x, y;
long long g = gcdextended(a, m, x, y);
if (g != 1) {
cout << "NOT POSSIBLE";
return -1;
} else
return (x % m + m) % m;
}
long long po(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long pom(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long root(long long x, vector<long long> &id) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void uni(long long x, long long y, vector<long long> &id) {
long long a = root(x, id);
long long b = root(y, id);
id[a] = id[b];
}
bool sec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
void solve() {
long long n, i, mi1 = LONG_LONG_MIN, ma1 = LONG_LONG_MAX, mi2 = LONG_LONG_MIN,
ma2 = LONG_LONG_MAX, mi3 = LONG_LONG_MIN, ma3 = LONG_LONG_MAX,
mi4 = LONG_LONG_MIN, ma4 = LONG_LONG_MAX;
cin >> n;
long long x, y;
cin >> x >> y;
char ch[n];
long long a[n], b[n];
map<pair<long long, long long>, char> fr;
for (i = 0; i < n; i++) {
cin >> ch[i] >> a[i] >> b[i];
fr[make_pair(a[i], b[i])] = ch[i];
}
long long u = 0, d = 0, l = 0, r = 0, ul = 0, ur = 0, dl = 0, dr = 0;
for (i = 0; i < n; i++) {
if (a[i] == x) {
if (b[i] < y)
mi1 = max(mi1, b[i]);
else
ma1 = min(ma1, b[i]);
} else if (b[i] == y) {
if (a[i] < x)
mi2 = max(mi2, a[i]);
else
ma2 = min(ma2, a[i]);
} else if (a[i] - b[i] == x - y) {
if (a[i] < x)
mi3 = max(mi3, a[i]);
else
ma3 = min(ma3, a[i]);
} else if (a[i] + b[i] == x + y) {
if (a[i] < x)
mi4 = max(mi4, a[i]);
else
ma4 = min(ma4, a[i]);
}
}
if (mi1 != LONG_LONG_MIN && fr[make_pair(x, mi1)] != 'B') d = 1;
if (ma1 != LONG_LONG_MAX && fr[make_pair(x, ma1)] != 'B') u = 1;
if (mi2 != LONG_LONG_MIN && fr[make_pair(mi2, y)] != 'B') l = 1;
if (ma2 != LONG_LONG_MAX && fr[make_pair(ma2, y)] != 'B') r = 1;
if (mi3 != LONG_LONG_MIN && fr[make_pair(mi3, mi3 + y - x)] != 'R') dl = 1;
if (ma3 != LONG_LONG_MAX && fr[make_pair(ma3, ma3 + y - x)] != 'R') ur = 1;
if (mi4 != LONG_LONG_MIN && fr[make_pair(mi4, x + y - mi4)] != 'R') ul = 1;
if (ma4 != LONG_LONG_MAX && fr[make_pair(ma4, x + y - ma4)] != 'R') dr = 1;
if (u || d || l || r || ul || ur || dl || dr)
cout << "YES";
else
cout << "NO";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
long long t;
t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
long long int l;
int n, d;
int a[100010], p[100010], b[100010], c[100010];
int i, j;
void swap(int *x, int *y) {
int tmp = *x;
*x = *y;
*y = tmp;
return;
}
int getNextX() {
l = (l * 37 + 10007) % 1000000007;
return l;
}
void initAB() {
for (i = 0; i < n; i = i + 1) a[i] = i + 1;
for (i = 1; i <= n; i++) p[i] = i - 1;
for (i = 0; i < n; i = i + 1) {
int k = getNextX() % (i + 1);
swap(&a[i], &a[k]);
swap(&p[a[i]], &p[a[k]]);
}
for (i = 0; i < n; i = i + 1) {
if (i < d)
b[i] = 1;
else
b[i] = 0;
}
for (i = 0; i < n; i = i + 1) swap(&b[i], &b[getNextX() % (i + 1)]);
return;
}
int main() {
scanf("%d%d%lld", &n, &d, &l);
initAB();
if (d > 500) {
for (i = n - 1; i >= 0; i--) {
for (j = n; j >= 1; j--)
if (i >= p[j] && b[i - p[j]]) {
c[i] = j;
break;
}
}
} else {
for (i = 0; i < n; i++) {
if (b[i] == 0) continue;
for (j = 0; j < n - i; j++)
if (a[j] > c[i + j]) c[i + j] = a[j];
}
}
for (i = 0; i < n; i++) printf("%d\n", c[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 10;
double dp[maxn][maxn];
int main() {
int n, t;
double p;
scanf("%d%lf%d", &n, &p, &t);
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
double ans = 0;
for (int i = 1; i <= t; i++) {
for (int j = 0; j <= n; j++) {
if (j == n)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = (1 - p) * dp[i - 1][j];
if (j) dp[i][j] += p * dp[i - 1][j - 1];
}
}
for (int i = 1; i <= n; i++) ans += dp[t][i] * i;
printf("%.8g\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Dim {
long long int x, y;
};
vector<vector<long long int> > g;
int main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
long long int first = 0, second = 0;
vector<long long int> middle;
for (long long int n = (0); n < (long long int)(N); ++n) {
int S;
cin >> S;
if (S % 2 == 0) {
for (long long int s = (0); s < (long long int)(S); ++s) {
int x;
cin >> x;
if (s < S / 2) {
first += x;
} else {
second += x;
}
}
} else {
for (long long int s = (0); s < (long long int)(S); ++s) {
int x;
cin >> x;
if (s < S / 2) {
first += x;
} else if (s == S / 2) {
middle.push_back(x);
} else {
second += x;
}
}
}
}
sort(middle.begin(), middle.end());
reverse(middle.begin(), middle.end());
for (long long int i = (0); i < (long long int)(middle.size()); ++i) {
if (i % 2 == 0) {
first += middle[i];
} else {
second += middle[i];
}
}
cout << first << " " << second << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
iostream::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
vector<long long> width(n);
map<int, int> m;
for (long long i = (0); i < (n); ++i) {
cin >> width[i];
m[width[i]] = i;
}
string s;
cin >> s;
vector<long long> ans(2 * n);
set<int, greater<int> > st_fill;
set<int> st_empty;
for (long long i = (0); i < (n); ++i) {
st_empty.insert(width[i]);
}
for (long long i = (0); i < (2 * n); ++i) {
if (s[i] == '0') {
auto it = st_empty.begin();
st_fill.insert(*it);
cout << m[*it] + 1 << " ";
st_empty.erase(it);
} else {
auto it = st_fill.begin();
cout << m[*it] + 1 << " ";
st_fill.erase(it);
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e5 + 100, mod = 1e9 + 7;
long long n;
vector<long long> adj[50];
vector<pair<long long, pair<long long, long long>>> ans;
bool shit[50];
long long poww(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
long long n = poww(a, b / 2);
if (b & 1) return n * n * a;
return n * n;
}
void f(long long v, long long dp, long long x, long long y, long long t) {
if (shit[v]) return;
bool b[5];
memset(b, 0, sizeof(b));
shit[v] = 1;
if (dp != -1) {
if (dp == 1)
dp = 3;
else if (dp == 2)
dp = 4;
else if (dp == 3)
dp = 1;
else if (dp == 4)
dp = 2;
b[dp] = 1;
}
ans.push_back({v, {x, y}});
for (long long i : adj[v]) {
if (shit[i]) continue;
for (long long j = 1; j <= 4; j++) {
if (b[j]) continue;
b[j] = 1;
if (j == 1) f(i, j, x, y + poww(2, t - 1), t - 1);
if (j == 2) f(i, j, x + poww(2, t - 1), y, t - 1);
if (j == 3) f(i, j, x, y - poww(2, t - 1), t - 1);
if (j == 4) f(i, j, x - poww(2, t - 1), y, t - 1);
break;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long v, u;
cin >> v >> u;
adj[u].push_back(v);
adj[v].push_back(u);
if (adj[u].size() > 4 || adj[v].size() > 4) return cout << "NO", 0;
}
cout << "YES" << endl;
f(1, -1, 0, 0, 40);
sort(ans.begin(), ans.end());
for (auto i : ans) {
auto p = i.second;
cout << p.first << " " << p.second << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double dist(long double x1, long double y1, long double x2,
long double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long gcd(long long a, long long b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long nok(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
ios::sync_with_stdio(false);
long double x1, y1, a;
cin >> x1 >> y1 >> a;
long double x2, y2, b;
cin >> x2 >> y2 >> b;
long double r1 = min(a, b), r2 = max(a, b);
long double s = dist(x1, y1, x2, y2);
cout << fixed << setprecision(9);
if (s - r1 - r2 >= 0) {
cout << (s - r1 - r2) / 2;
} else {
if (r1 + s <= r2) {
cout << (r2 - r1 - s) / 2;
} else {
cout << 0;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
long long ksm(long long a, long long b, long long m) {
long long sum = 1;
a %= m;
while (b > 0) {
if (b & 1) sum = (sum * a) % m;
a = (a * a) % m;
b >>= 1;
}
return sum;
}
int a[N], in[N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int b = 0, c = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i] == -1)
b++;
else
c++;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!in[i]) {
in[i] = 1;
int b1 = 0, c1 = 0;
for (int j = i; j <= n; j += k) {
in[j] = 1;
if (a[j] == -1)
b1++;
else
c1++;
}
for (int j = i - k; j >= 1; j -= k) {
in[j] = 1;
if (a[j] == -1)
b1++;
else
c1++;
}
ans = max(abs((c - c1) - (b - b1)), ans);
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.