solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
namespace my_useful_tools {
const int INF = 0x3f3f3f3f;
inline void pc(char c) { putchar(c); }
template <class T>
inline T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <class T>
inline void W(T p) {
if (p < 0) pc('-'), p = -p;
if (p / 10 != 0) W(p / 10);
pc('0' + p % 10);
}
template <class T>
inline void Wn(T p) {
W(p), puts("");
}
template <class T>
inline void W(T a, T b) {
W(a), pc(' '), W(b);
}
template <class T>
inline void Wn(T a, T b) {
W(a), pc(' '), Wn(b);
}
template <class T>
inline void W(T a, T b, T c) {
W(a), pc(' '), W(b), pc(' '), W(c);
}
inline char gchar() {
char ret = getchar();
for (; ret == '\n' || ret == '\r' || ret == ' '; ret = getchar())
;
return ret;
}
template <class T>
inline void fr(T& ret) {
char c = ' ';
int flag = 1;
for (c = getchar(); c != '-' && !('0' <= c && c <= '9'); c = getchar())
;
if (c == '-')
flag = -1, ret = 0;
else
ret = c - '0';
for (c = getchar(); '0' <= c && c <= '9'; c = getchar())
ret = ret * 10 + c - '0';
ret = ret * flag;
}
inline int fr() {
int x;
fr(x);
return x;
}
template <class T>
inline void fr(T& a, T& b) {
fr(a), fr(b);
}
template <class T>
inline void fr(T& a, T& b, T& c) {
fr(a), fr(b), fr(c);
}
template <class T>
inline T fast_pow(T base, T index, T mod = 2147483647, T ret = 1) {
for (; index; index >>= 1, base = base * base % mod)
if (index & 1) ret = ret * base % mod;
return ret;
}
const int maxv = 100, maxe = 100;
struct Edge {
int edge, head[maxv], to[maxe], next[maxe];
Edge() {
edge = 0;
memset(head, -1, sizeof head);
}
void addedge(int u, int v) {
to[edge] = v, next[edge] = head[u];
head[u] = edge++;
}
};
}; // namespace my_useful_tools
using namespace my_useful_tools;
const int maxn = 1e5 + 100;
const int maxc = 1e6 + 10;
const int maxr = 2e6 + 100;
int x[maxn], y[maxn];
double x1[maxr], x2[maxr];
int n, cnt[maxr];
double ans;
void calc() {
int mi = INF, mx = -INF;
for (int i = 0; i < maxr; ++i) {
x1[i] = mx, x2[i] = mi;
}
for (int i = 1; i <= n; ++i) {
int ux = x[i], uy = y[i], vx = x[i + 1 > n ? 1 : i + 1],
vy = y[i + 1 > n ? 1 : i + 1];
mi = min(mi, ux), mx = max(mx, ux);
if (ux == vx) {
x1[ux] = max(1. * max(uy, vy), x1[ux]);
x2[ux] = min(1. * min(uy, vy), x2[ux]);
} else {
if (vx < ux) {
swap(ux, vx), swap(uy, vy);
}
for (int r = ux; r <= vx; ++r) {
double t = 1. * (uy - vy) / (ux - vx) * (r - ux) + uy;
x1[r] = max(x1[r], t);
x2[r] = min(x2[r], t);
}
}
}
long long tot = 0;
for (int i = mi; i <= mx; ++i) {
int dn = (int)(x2[i] - 1e-5) + 1, up = (int)(x1[i]);
tot += (cnt[i - mi] = up - dn + 1);
}
double sum = 0, s1 = 0, s2 = 0, s3 = 0;
for (int i = 0; i <= mx - mi; ++i) {
sum += 1. * cnt[i] * (1. * i * i * s1 - 2. * i * s2 + s3);
s1 += cnt[i];
s2 += 1. * i * cnt[i];
s3 += 1. * i * i * cnt[i];
}
sum /= (1. * tot * (tot - 1) / 2);
ans += sum;
}
int main() {
fr(n);
for (int i = 1; i <= n; ++i) {
fr(x[i], y[i]);
x[i] += 1000000, y[i] += 1000000;
}
calc();
for (int i = 1; i <= n; ++i) {
swap(x[i], y[i]);
}
calc();
printf("%.10lf\n", ans / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, V = 1000000, MV = 1001000, Inf = 1 << 30;
const double eps(1e-8);
int n, x[N] = {}, y[N] = {};
double ul[MV + MV] = {}, ur[MV + MV] = {}, *l = ul + MV, *r = ur + MV;
double ans = 0;
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &x[i], &y[i]);
x[n + 1] = x[1], y[n + 1] = y[1];
}
long long sqrsum(long long l, long long r) {
if (l == 1)
return r * (r + 1) * (r + r + 1) / 6;
else if (l > 1)
return sqrsum(1, r) - sqrsum(1, l - 1);
else
return sqrsum(1, -l) + sqrsum(1, r);
}
void work() {
double s0 = 0, s1 = 0, s2 = 0;
for (int i = -V; i <= V; ++i) l[i] = Inf, r[i] = -Inf;
int lx = V, rx = -V;
for (int i = 1; i <= n; ++i) {
lx = min(lx, x[i]), rx = max(rx, x[i]);
if (x[i] == x[i + 1])
l[x[i]] = min(y[i], y[i + 1]), r[x[i]] = max(y[i], y[i + 1]);
else {
bool flag = false;
if (x[i] > x[i + 1]) flag = true;
if (flag) swap(x[i], x[i + 1]), swap(y[i], y[i + 1]);
double t = 1.0 / (x[i + 1] - x[i]);
for (int j = x[i]; j <= x[i + 1]; ++j) {
double c = ((long long)(j - x[i]) * y[i + 1] +
(long long)(x[i + 1] - j) * y[i]) *
t;
l[j] = min(l[j], c);
r[j] = max(r[j], c);
}
if (flag) swap(x[i], x[i + 1]), swap(y[i], y[i + 1]);
}
}
for (int i = lx; i <= rx; ++i) {
long long tl = (int)ceil(l[i]), tr = (int)floor(r[i]);
s0 += tr - tl + 1;
s1 += (tr + tl) * (tr - tl + 1) / 2;
s2 += sqrsum(tl, tr);
}
ans += (s0 * s2 - s1 * s1) / s0 / (s0 - 1);
}
void swapxy() {
for (int i = 1; i <= n + 1; ++i) swap(x[i], y[i]);
}
int main() {
init();
work();
swapxy();
work();
printf("%.10f\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int N = 110000, M = 2100000, Zero = 1000000;
struct Point {
int x, y;
} P[N];
int i, j, k, l, m, n, o, p, X[M], Y[M], Lx, Rx, Ly, Ry;
inline int sn(double x) { return x < -eps ? -1 : x > eps ? 1 : 0; }
inline void Init() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d", &P[i].x, &P[i].y);
}
inline double gety(double x, int A, int B) {
return P[A].y + (x - P[A].x) / (P[B].x - P[A].x) * (P[B].y - P[A].y);
}
inline void SolveX() {
int x, s, t, U, D, lU, lD;
s = t = 1;
double x1, x2, w;
for (i = 1; i <= n; i++) {
if (P[i].x < P[s].x) s = i;
if (P[i].x > P[t].x) t = i;
}
U = s + 1;
if (U > n) U = 1;
D = s - 1;
if (!D) D = n;
lU = lD = s;
if (P[lU].x == P[U].x) {
lU = U;
U++;
if (U > n) U = 1;
}
if (P[lD].x == P[D].x) {
lD = D;
D--;
if (D < 1) D = n;
}
for (x = P[s].x; x <= P[t].x; x++) {
while (P[U].x < x) {
lU = U;
U++;
if (U > n) U = 1;
}
while (P[D].x < x) {
lD = D;
D--;
if (D < 1) D = n;
}
x1 = gety((double)x, lU, U);
x2 = gety((double)x, lD, D);
if (sn(x1 - x2) > 0) {
w = x1;
x1 = x2;
x2 = w;
}
x1 = ceil(x1);
x2 = floor(x2);
X[x + Zero] = (int)(x2) - (int)(x1) + 1;
}
Lx = P[s].x;
Rx = P[t].x;
}
inline double getx(double y, int A, int B) {
return P[A].x + (y - P[A].y) / (P[B].y - P[A].y) * (P[B].x - P[A].x);
}
inline void SolveY() {
int y, s, t, L, R, lL, lR;
s = t = 1;
double y1, y2, w;
for (i = 1; i <= n; i++) {
if (P[i].y < P[s].y) s = i;
if (P[i].y > P[t].y) t = i;
}
L = s + 1;
if (L > n) L = 1;
R = s - 1;
if (!R) R = n;
lL = lR = s;
if (P[lL].y == P[L].y) {
lL = L;
L++;
if (L > n) L = 1;
}
if (P[lR].y == P[R].y) {
lR = R;
R--;
if (R < 1) R = n;
}
for (y = P[s].y; y <= P[t].y; y++) {
while (P[L].y < y) {
lL = L;
L++;
if (L > n) L = 1;
}
while (P[R].y < y) {
lR = R;
R--;
if (R < 1) R = n;
}
y1 = getx((double)y, lL, L);
y2 = getx((double)y, lR, R);
if (sn(y1 - y2) > 0) {
w = y1;
y1 = y2;
y2 = w;
}
y1 = ceil(y1);
y2 = floor(y2);
Y[y + Zero] = (int)(y2) - (int)(y1) + 1;
}
Ly = P[s].y;
Ry = P[t].y;
}
inline double Solve() {
double ans = 0.0, s0, s1, s2, p, g, x, cul, y;
s0 = 0.0;
s1 = 0.0;
s2 = 0.0;
for (i = Lx; i <= Rx; i++) {
g = (double)X[i + Zero];
x = (double)i;
cul = x * x * s0 + s2 - 2.0 * x * s1;
ans += cul * g;
s0 += g;
s2 += g * x * x;
s1 += g * x;
}
s0 = 0.0;
s1 = 0.0;
s2 = 0.0;
for (i = Ly; i <= Ry; i++) {
g = (double)Y[i + Zero];
y = (double)i;
cul = y * y * s0 + s2 - 2.0 * y * s1;
ans += cul * g;
s0 += g;
s2 += g * y * y;
s1 += g * y;
}
p = s0 * (s0 - 1.0);
return ans / p;
}
int main() {
Init();
SolveX();
SolveY();
printf("%.8lf\n", Solve());
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
struct pt {
int x, y;
pt() {}
pt(int x, int y) : x(x), y(y) {}
friend bool operator<(const pt &a, const pt &b) {
if (a.y == b.y) return a.x < b.x;
return a.y < b.y;
}
};
struct seg {
pt a, b;
long long A, B, C;
seg() {}
seg(pt a, pt b) : a(a), b(b) {
A = a.y - b.y;
B = b.x - a.x;
C = A * a.x + B * a.y;
}
int cut_r(int y) {
int x = (C - B * y) / A;
if (A * x + B * y < C) ++x;
return x;
}
int cut_l(int y) {
int x = (C - B * y) / A;
if (A * x + B * y > C) --x;
return x;
}
};
int n, x, y;
vector<pt> p;
vector<seg> L;
vector<seg> R;
double tot;
double sum_range(int l, int r) {
if (l > r) return 0;
double len = r - l + 1;
return len * l + len * (len - 1) * 0.5;
}
double _sum_squares(int n) {
double ret = (double)(n + 1) * n * (n - 1) / 3;
ret += (double)n * (n + 1) / 2;
return ret;
}
double sum_squares(int l, int r) {
if (l > r) return 0;
if (l <= 0 && r >= 0) return _sum_squares(abs(l)) + _sum_squares(abs(r));
l = abs(l);
r = abs(r);
if (l > r) swap(l, r);
double ret = _sum_squares(r);
if (l) ret -= _sum_squares(l - 1);
return ret;
}
double solve() {
int miny = +inf;
int maxy = -inf;
long long area = 0;
for (int i = (0); i < (n); ++i) {
miny = min(miny, p[i].y);
maxy = max(maxy, p[i].y);
int j = (i + 1) % n;
area += (long long)p[i].x * p[j].y - (long long)p[i].y * p[j].x;
}
if (area < 0) reverse(p.begin(), p.end());
L.clear();
R.clear();
rotate(p.begin(), max_element(p.begin(), p.end()), p.end());
for (int i = ((p[0].y == p[1].y)); i < (n); ++i) {
if (p[i].y == miny) break;
L.push_back(seg(p[i], p[i + 1]));
}
R.push_back(seg(p[0], p.back()));
for (int i = (0); i < (n); ++i) {
if (p[n - i - 1].y == miny) break;
R.push_back(seg(p[n - i - 1], p[n - i - 2]));
}
tot = 0.0;
double sum = 0.0;
double sum_sq = 0.0;
int li = 0, ri = 0;
for (int y = maxy; y >= miny; --y) {
if (y < L[li].b.y) ++li;
if (y < R[ri].b.y) ++ri;
int l = L[li].cut_r(y);
int r = R[ri].cut_l(y);
tot += r - l + 1;
sum += sum_range(l, r);
sum_sq += sum_squares(l, r);
}
return 2.0 * sum_sq - 2.0 * (sum / tot) * sum;
}
int main(void) {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) {
scanf("%d%d", &x, &y);
p.push_back(pt(x, y));
}
double sol = 0.0;
sol += solve();
for (int i = (0); i < (n); ++i) swap(p[i].x, p[i].y);
sol += solve();
sol /= (tot - 1.0);
sol *= 0.5;
printf("%.8lf\n", sol);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y;
Point() {}
Point(long long x0, long long y0) : x(x0), y(y0) {}
void in() { scanf("%I64d %I64d", &x, &y); }
long long operator*(Point pt) { return x * pt.y - y * pt.x; }
Point operator-(Point pt) { return Point(x - pt.x, y - pt.y); }
} p[100010];
long long judge1(long long y, Point a, Point b) {
if (a.y == b.y) return min(a.x, b.x);
long long left = -2000000;
long long right = 2000000;
long long ans;
while (right >= left) {
long long mid = (left + right) / 2;
Point o = Point(mid, y);
if ((b - a) * (o - a) > 0)
left = mid + 1;
else {
ans = mid;
right = mid - 1;
}
}
return ans;
}
long long judge2(long long y, Point a, Point b) {
if (a.y == b.y) return max(a.x, b.x);
long long left = -2000000;
long long right = 2000000;
long long ans;
while (right >= left) {
long long mid = (left + right) / 2;
Point o = Point(mid, y);
if ((b - a) * (o - a) >= 0) {
ans = mid;
left = mid + 1;
} else
right = mid - 1;
}
return ans;
}
long long x[2000010];
int n;
double solve() {
p[n] = p[0];
p[n + 1] = p[1];
bool need = false;
for (int i = 0; i < n; i++) {
if ((p[i + 1] - p[i]) * (p[i + 2] - p[i]) == 0) continue;
if ((p[i + 1] - p[i]) * (p[i + 2] - p[i]) < 0) {
need = true;
break;
}
}
if (need) reverse(p, p + n);
p[n] = p[0];
p[n + 1] = p[1];
long long left = (1LL) << 60;
long long right = -(1LL) << 60;
int begin = 0;
for (int i = 0; i < n; i++) {
if (p[i].y < left) {
left = p[i].y;
begin = i;
}
if (p[i].y > right) right = p[i].y;
}
int l, r, ll, rr;
l = r = begin;
for (long long t = left; t <= right; t++) {
while (1) {
ll = (l - 1 + n) % n;
if (p[ll].y > t || p[ll].y == right) break;
l = ll;
}
while (1) {
rr = (r + 1) % n;
if (p[rr].y > t || p[rr].y == right) break;
r = rr;
}
long long a = judge1(t, p[l], p[ll]);
long long b = judge2(t, p[r], p[rr]);
x[t - left] = b - a + 1;
}
double T = 0;
for (int i = left; i <= right; i++) T += x[i - left];
double ans = 0;
double a0 = 0;
double a1 = 0;
double a2 = 0;
for (int t = left; t < right; t++) {
a1 += a0 + x[t - left];
a2 += a1;
a0 += x[t - left] * 2;
ans += a2 * x[t - left + 1];
}
ans /= T;
ans /= T - 1.0;
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) p[i].in();
double ans = 0;
ans += solve();
for (int i = 0; i < n; i++) swap(p[i].x, p[i].y);
ans += solve();
printf("%.12f\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
};
int N;
point P[100010];
long long area(point &P, point &Q) { return P.x * Q.y - P.y * Q.x; }
bool smaller(point &P, point &Q) {
if (P.x < Q.x) return true;
if (P.x == Q.x && P.y < Q.y) return true;
return false;
}
long long low[2000010], high[2000010];
void lower(point P, point Q) {
if (P.x == Q.x) return;
for (int i = P.x; i <= Q.x; i++) {
double y = P.y + (double)(Q.y - P.y) / (Q.x - P.x) * (i - P.x);
low[i] = max(low[i], (long long)(y - 1.0E-7) + 1);
}
}
void upper(point P, point Q) {
if (P.x == Q.x) return;
for (int i = P.x; i <= Q.x; i++) {
double y = P.y + (double)(Q.y - P.y) / (Q.x - P.x) * (i - P.x);
high[i] = min(high[i], (long long)(y + 1.0E-7));
}
}
double func(void) {
int i;
long long s = 0;
for ((i) = 0; (i) < (int)(N); (i)++) s += area(P[i], P[(i + 1) % N]);
if (s < 0) reverse(P, P + N);
int L = 0, R = 0;
for ((i) = 0; (i) < (int)(N); (i)++) {
if (smaller(P[i], P[L])) L = i;
if (smaller(P[R], P[i])) R = i;
}
int X1 = P[L].x;
int X2 = P[R].x;
for (i = X1; i <= X2; i++) low[i] = -(1 << 29);
for (i = X1; i <= X2; i++) high[i] = (1 << 29);
for (i = 0;; i++) {
int a = (L + i) % N, b = (L + i + 1) % N;
lower(P[a], P[b]);
if (b == R) break;
}
for (i = 0;; i++) {
int a = (R + i + 1) % N, b = (R + i) % N;
upper(P[a], P[b]);
if (a == L) break;
}
double cnt = 0.0;
double xsum = 0.0;
double x2sum = 0.0;
int sy = X2 - X1;
for (i = 0; i <= sy; i++) {
double tmp = high[i + X1] - low[i + X1] + 1;
cnt += tmp;
xsum += tmp * (double)i;
x2sum += tmp * (double)i * (double)i;
}
double ans = 2.0 * cnt * x2sum - 2.0 * xsum * xsum;
return ans / cnt / (cnt - 1.0);
}
int main(void) {
int i;
cin >> N;
for ((i) = 0; (i) < (int)(N); (i)++) {
int x, y;
scanf("%d%d", &x, &y);
P[i].x = x + 1000000;
P[i].y = y + 1000000;
}
double ans1 = func();
for ((i) = 0; (i) < (int)(N); (i)++) swap(P[i].x, P[i].y);
double ans2 = func();
printf("%.9f\n", (ans1 + ans2) / 2.0);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, V = 1000000, MV = 1001000, Inf = 1 << 30;
const double eps(1e-8);
int n, x[N] = {}, y[N] = {}, ul[MV + MV] = {}, ur[MV + MV] = {}, *l = ul + MV,
*r = ur + MV;
double ans = 0;
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &x[i], &y[i]);
x[n + 1] = x[1], y[n + 1] = y[1];
}
void work() {
double s0 = 0, s1 = 0, s2 = 0;
for (int i = -V; i <= V; ++i) l[i] = Inf, r[i] = -Inf;
int lx = V, rx = -V;
for (int i = 1; i <= n; ++i) {
lx = min(lx, x[i]), rx = max(rx, x[i]);
if (x[i] == x[i + 1])
l[x[i]] = min(y[i], y[i + 1]), r[x[i]] = max(y[i], y[i + 1]);
else {
bool flag = false;
if (x[i] > x[i + 1]) flag = true;
if (flag) swap(x[i], x[i + 1]), swap(y[i], y[i + 1]);
double t = 1.0 / (x[i + 1] - x[i]);
for (int j = x[i]; j <= x[i + 1]; ++j) {
double c = ((long long)(j - x[i]) * y[i + 1] +
(long long)(x[i + 1] - j) * y[i]) *
t;
l[j] = min(l[j], (int)ceil(c));
r[j] = max(r[j], (int)floor(c));
}
if (flag) swap(x[i], x[i + 1]), swap(y[i], y[i + 1]);
}
}
for (int i = lx; i <= rx; ++i) {
long long d = r[i] - l[i] + 1;
s0 += d, s1 += d * i, s2 += d * i * i;
}
ans += (s0 * s2 - s1 * s1) / s0 / (s0 - 1);
}
void swapxy() {
for (int i = 1; i <= n + 1; ++i) swap(x[i], y[i]);
}
int main() {
init();
work();
swapxy();
work();
printf("%.10f\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using Point = complex<long long>;
long long det(Point a, Point b, Point c) {
b -= a;
c -= a;
return (conj(b) * c).imag();
}
void Trim(vector<Point>& p) {
while (p[0].real() == p[1].real()) p.erase(p.begin());
while (p.end()[-1].real() == p.end()[-2].real()) p.pop_back();
}
long double Solve(vector<Point> p) {
int n = p.size();
double area = 0;
for (int i = 0, j = n - 1; i < n; j = i++) area += det(0, p[j], p[i]);
if (area < 0) reverse(p.begin(), p.end());
tuple<long long, long long, int> fst = {+2000000, -1, -1};
for (int i = 0; i < n; ++i)
fst = min(fst, make_tuple(p[i].real(), p[i].imag(), i));
rotate(p.begin(), p.begin() + get<2>(fst), p.end());
p.push_back(p[0]);
tuple<long long, long long, int> snd = {-2000000, -1, -1};
for (int i = 0; i < n; ++i)
snd = max(snd, make_tuple(p[i].real(), p[i].imag(), i));
vector<Point> lo(p.begin(), p.begin() + get<2>(snd) + 1);
vector<Point> hi(p.begin() + get<2>(snd), p.end());
reverse(hi.begin(), hi.end());
Trim(lo);
Trim(hi);
long long minx = get<0>(fst), maxx = get<0>(snd);
vector<int> cnt(maxx - minx + 1);
long long miny = 0, maxy = 0;
int i = 0, j = 0;
for (long long x = minx; x <= maxx; ++x) {
while (det(lo[i], lo[i + 1], Point{x, miny}) < 0) ++miny;
while (det(lo[i], lo[i + 1], Point{x, miny - 1}) >= 0) --miny;
while (det(hi[j], hi[j + 1], Point{x, maxy}) > 0) --maxy;
while (det(hi[j], hi[j + 1], Point{x, maxy + 1}) <= 0) ++maxy;
cnt[x - minx] = maxy - miny + 1;
if (x == lo[i + 1].real()) ++i;
if (x == hi[j + 1].real()) ++j;
}
long long total = 0;
for (int x = 0; x <= maxx - minx; ++x) total += cnt[x];
long double exp = 0, expsq = 0;
for (int x = 0; x <= maxx - minx; ++x) {
exp += 1.0L * x * cnt[x] / total;
expsq += 1.0L * x * x / total * cnt[x];
}
long double ans = 0;
for (int x = 0; x <= maxx - minx; ++x) {
long double add = 1.0L * x * x + expsq - 2.0L * x * exp;
ans += add / (total - 1) * cnt[x];
}
return ans;
}
int main() {
int n;
cin >> n;
vector<Point> p(n);
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
p[i] = Point{x, y};
}
long double ans = 0;
for (int it = 0; it < 2; ++it) {
ans += Solve(p);
for (int i = 0; i < n; ++i) {
long long x = p[i].real(), y = p[i].imag();
p[i] = Point{y, x};
}
}
cout << fixed << setprecision(20) << 0.5L * ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
void init() {
scanf("%d%d", &x, &y);
x += 1000000;
y += 1000000;
}
void swap() {
x ^= y;
y ^= x;
x ^= y;
}
};
const int MAXN = 100000;
int n;
Point points[MAXN];
int fix(int x) { return x < 0 ? x + n : x >= n ? x - n : x; }
int getLower(int x, const Point &u, const Point &v) {
if (u.x == v.x) return min(u.y, v.y);
return (v.y * (long long)(v.x - u.x) - (v.x - x) * (long long)(v.y - u.y) +
v.x - u.x - 1) /
(v.x - u.x);
}
int getUpper(int x, const Point &u, const Point &v) {
if (u.x == v.x) return max(u.y, v.y);
return (v.y * (long long)(v.x - u.x) - (v.x - x) * (long long)(v.y - u.y)) /
(v.x - u.x);
}
long double squareSum(long double l, long double u) {
long double res = (u - l + 1) / 6;
res += (u - l + 1) * (u + l - 1) / 2;
res += (u - l + 1) * (u * u + u * (l - 1) + (l - 1) * (l - 1)) / 3;
return res;
}
long double calc() {
int p1 = 0, d1, p2, d2, minx = points[0].x, maxx = points[0].x;
for (int i = (1); i < (n); i++) {
if (points[p1].x > points[i].x) p1 = i;
minx = min(minx, points[i].x);
maxx = max(maxx, points[i].x);
}
p2 = p1;
d1 = 1;
d2 = -1;
if (points[fix(p1 + d1)].y > points[fix(p2 + d2)].y) swap(d1, d2);
long double sum = 0, sum2 = 0, m = 0;
for (int x = (minx); x < (maxx + 1); x++) {
int nxtp1 = fix(p1 + d1), nxtp2 = fix(p2 + d2);
int lower = getLower(x, points[p1], points[nxtp1]);
int upper = getUpper(x, points[p2], points[nxtp2]);
if (points[nxtp1].x == x) p1 = nxtp1;
if (points[nxtp2].x == x) p2 = nxtp2;
m += upper - lower + 1;
sum += (lower + upper) * (upper - lower + 1.0) / 2;
sum2 += squareSum(lower, upper);
}
return sum2 / (m - 1) - sum / m / (m - 1) * sum;
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) points[i].init();
long double res = calc();
for (int i = (0); i < (n); i++) points[i].swap();
res += calc();
printf("%.16lf\n", (double)res);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> x(n), y(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
}
int mx = *min_element(x.begin(), x.end());
int my = *min_element(y.begin(), y.end());
for (int i = 0; i < n; ++i) {
x[i] -= mx;
y[i] -= my;
}
double res = 0;
bool isY = false;
makeY:
trap:
int MX = *max_element(x.begin(), x.end());
vector<int> count(MX + 1);
for (int i = 0; i < n; ++i) {
int x1 = x[i];
int x2 = x[(i + 1) % n];
int y1 = y[i];
int y2 = y[(i + 1) % n];
if (x1 == x2) {
continue;
}
if (x1 < x2) {
if (x2 == MX) count[x2] += y2;
for (int X = 0; X + x1 < x2; ++X) {
count[x1 + X] += y1;
if (y1 <= y2) {
count[x1 + X] += 1LL * (y2 - y1) * X / (x2 - x1);
} else {
count[x1 + X] -= (1LL * (y1 - y2) * X + (x2 - x1) - 1) / (x2 - x1);
}
}
} else {
if (x2 == 0) count[0] -= y2 - 1;
for (int X = 1; X + x2 <= x1; ++X) {
count[x2 + X] -= y2;
if (y1 >= y2) {
count[x2 + X] -= (1LL * (y1 - y2) * X) / (x1 - x2);
if ((1LL * (y1 - y2) * X) % (x1 - x2) == 0) count[x2 + X]++;
} else {
count[x2 + X] += 1LL * (y2 - y1) * X / (x1 - x2) + 1;
}
}
}
}
if (*min_element(count.begin(), count.end()) < 0) {
reverse(x.begin(), x.end());
reverse(y.begin(), y.end());
goto trap;
}
double sumX = 0;
double sumXS = 0;
double cnt = 0;
for (int i = 0; i <= MX; ++i) {
res += count[i] * (sumXS - sumX * 2 * i + 1.0 * i * i * cnt);
sumXS += 1.0 * count[i] * i * i;
sumX += 1.0 * count[i] * i;
cnt += count[i];
}
if (isY == false) {
isY = true;
for (int i = 0; i < n; ++i) swap(x[i], y[i]);
goto makeY;
}
res /= cnt * (cnt - 1) / 2;
printf("%.10lf\n", res / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1 << 17, MIL = 1 << 21;
int n;
pair<int, int> p[MAX];
int br[MIL];
int Norm(int x) { return (x + n) % n; }
long long Ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
return (long long)a.first * (b.second - c.second) +
(long long)b.first * (c.second - a.second) +
(long long)c.first * (a.second - b.second);
}
inline long long SumBr(int x) { return (long long)x * (x + 1) / 2; }
inline long double SumKvad(int x) {
return (long double)x * (x + 1) * (2 * x + 1) / 6;
}
inline long long Sq(long long x) { return x * x; }
long double Rijesi() {
memset(br, 0, sizeof br);
int najvisa = 0, najniza = 0;
int lduz = 0, rduz = 0;
for (int i = 1; i < n; i++) {
if (p[i].second > p[najvisa].second) {
najvisa = i;
lduz = rduz = najvisa;
} else if (p[i].second == p[najvisa].second) {
if (p[i].first < p[lduz].first) lduz = i;
if (p[i].first > p[rduz].first) rduz = i;
}
if (p[i].second < p[najniza].second) najniza = i;
}
int ltoc = 0, rtoc = MIL - 5;
long long brtoc = 0;
for (int vis = p[najvisa].second; vis >= p[najniza].second; vis--) {
for (; vis < p[Norm(lduz + 1)].second; lduz = Norm(lduz + 1))
;
for (; vis < p[Norm(rduz - 1)].second; rduz = Norm(rduz - 1))
;
int pr = lduz, dr = Norm(lduz + 1);
for (; ltoc - 1 >= min(p[pr].first, p[dr].first) &&
Ccw(p[pr], p[dr], pair<int, int>(ltoc - 1, vis)) >= 0;
ltoc--)
;
for (; ltoc < min(p[pr].first, p[dr].first) ||
Ccw(p[pr], p[dr], pair<int, int>(ltoc, vis)) < 0;
ltoc++)
;
pr = Norm(rduz - 1), dr = rduz;
for (; rtoc + 1 <= max(p[pr].first, p[dr].first) &&
Ccw(p[pr], p[dr], pair<int, int>(rtoc + 1, vis)) >= 0;
rtoc++)
;
for (; rtoc > max(p[pr].first, p[dr].first) ||
Ccw(p[pr], p[dr], pair<int, int>(rtoc, vis)) < 0;
rtoc--)
;
br[vis] = max(0, rtoc - ltoc + 1);
brtoc += br[vis];
}
long double koef = (long double)1 / ((long double)brtoc * (brtoc - 1) / 2);
long double ret = 0;
long double sumkvad = 0, sumlin = 0;
long double broj = 0;
for (int i = 0; i < MIL; i++) {
ret += koef * br[i] * (Sq(i) * broj + sumkvad - 2 * sumlin * i);
broj += br[i];
sumlin += (long double)i * br[i];
sumkvad += (long double)Sq(i) * br[i];
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
p[i].first += MIL / 2;
p[i].second += MIL / 2;
}
int rev = 0;
for (int i = 0; i < n; i++)
if (Ccw(p[i], p[Norm(i + 1)], p[Norm(i + 2)]) < 0) rev = 1;
if (rev) reverse(p, p + n);
long double rje = Rijesi();
for (int i = 0; i < n; i++) swap(p[i].first, p[i].second);
rev = 0;
for (int i = 0; i < n; i++)
if (Ccw(p[i], p[Norm(i + 1)], p[Norm(i + 2)]) < 0) rev = 1;
if (rev) reverse(p, p + n);
rje += Rijesi();
printf("%.10lf\n", (double)rje / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
struct point {
int x, y;
};
int n;
point p[100020];
double totcnt;
double sdsq() {
int mxx = p[0].x;
int bi = 0;
for (int i = 1; i < n; ++i) {
if (p[i].x < p[bi].x) bi = i;
mxx = max(mxx, p[i].x);
}
int lo, hi;
lo = hi = bi;
int lpr = lo - 1;
if (lpr < 0) lpr += n;
int hne = hi + 1;
if (hne >= n) hne -= n;
while (p[lpr].x == p[lo].x) {
lo = lpr;
--lpr;
if (lpr < 0) lpr += n;
}
while (p[hne].x == p[hi].x) {
hi = hne;
++hne;
if (hne >= n) hne -= n;
}
double ymi = min(p[hi].y, p[lo].y);
double ymx = max(p[hi].y, p[lo].y);
double ans = 0.0;
double spr = 0;
double tot = 0;
double cx = p[hi].x;
while (cx <= mxx) {
double yx, yi;
if (cx == p[hne].x) {
hi = hne;
++hne;
if (hne >= n) hne -= n;
while (p[hne].x == p[hi].x) {
hi = hne;
++hne;
if (hne >= n) hne -= n;
}
}
if (cx == p[lpr].x) {
lo = lpr;
--lpr;
if (lpr < 0) lpr += n;
while (p[lpr].x == p[lo].x) {
lo = lpr;
--lpr;
if (lpr < 0) lpr += n;
}
}
double a, b, c;
a = p[hi].y - p[hne].y;
b = p[hne].x - p[hi].x;
c = -a * p[hi].x - b * p[hi].y;
yx = (-c - a * cx) / b;
a = p[lo].y - p[lpr].y;
b = p[lpr].x - p[lo].x;
c = -a * p[lo].x - b * p[lo].y;
yi = (-c - a * cx) / b;
ymi = (int)ceil(min(yx, yi));
ymx = (int)floor(max(yx, yi));
double cnt = ymx - ymi + 1;
ans += (double)(totcnt - cnt) * cnt * cx * cx;
ans -= 2.0 * (double)spr * cnt * cx;
tot += cnt;
spr += cnt * cx;
++cx;
}
totcnt = tot;
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &p[i].x, &p[i].y);
}
sdsq();
double sm = sdsq();
for (int i = 0; i < n; i++) {
swap(p[i].x, p[i].y);
}
sm += sdsq();
printf("%.10lf\n", sm / ((double)totcnt) / ((double)totcnt - 1.0));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x[100010], y[100010], n;
int CEIL(long long a, long long b) {
if (b < 0) a = -a, b = -b;
if (a < 0) return -((-a) / b);
return a / b + (a % b != 0);
}
int FLOOR(long long a, long long b) {
if (b < 0) a = -a, b = -b;
if (a > 0) return a / b;
a = -a;
int ans = a / b;
if (a % b) ans++;
return -ans;
}
int CEIL(int p1, int p2, int Y) {
if (y[p1] == y[p2]) return min(x[p1], x[p2]);
return x[p1] + CEIL(1LL * (Y - y[p1]) * (x[p2] - x[p1]), y[p2] - y[p1]);
}
int FLOOR(int p1, int p2, int Y) {
if (y[p1] == y[p2]) return max(x[p1], x[p2]);
return x[p1] + FLOOR(1LL * (Y - y[p1]) * (x[p2] - x[p1]), y[p2] - y[p1]);
}
int num[2000010];
double cal() {
long long s = 0;
for (int i = 0; i < n; i++)
s += 1LL * x[i] * y[(i + 1) % n] - 1LL * y[i] * x[(i + 1) % n];
if (s < 0) reverse(x, x + n), reverse(y, y + n);
int p1 = 0, p2 = 0;
for (int i = 1; i < n; i++)
if (y[i] > y[p1]) p1 = i, p2 = i;
int mi = (int)1e8;
for (int i = 0; i < n; i++) mi = min(mi, y[i]);
memset(num, 0, sizeof(num));
for (int i = y[p1]; i >= mi; i--) {
int L = CEIL(p1, (p1 + 1) % n, i);
int R = FLOOR(p2, (p2 - 1 + n) % n, i);
num[i] = R - L + 1;
if (num[i] < 0) puts("fuck");
if (i == y[(p1 + 1) % n]) p1 = (p1 + 1) % n;
if (i == y[(p2 - 1 + n) % n]) p2 = (p2 - 1 + n) % n;
}
long long cnt = 0;
for (int i = 0; i < 2000000; i++) cnt += num[i];
s = 0;
for (int i = 0; i < 2000000; i++) s += 1LL * i * num[i];
double ans = 0;
for (int i = 0; i < 2000000; i++)
if (num[i]) ans += 1.0 * i * num[i] / (cnt - 1) * (i - 1.0 * s / cnt);
return ans;
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) scanf("%d %d", &x[i], &y[i]);
for (int i = 0; i < n; i++) x[i] += 1000000, y[i] += 1000000;
double ans = cal();
for (int i = 0; i < n; i++) swap(x[i], y[i]);
ans += cal();
printf("%.10f\n", ans);
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x[100005], y[100005];
int up[2000005], down[2000005];
int A = 1000000;
bool on(int i, int j, int nx, int ny) {
return 1LL * (x[j] - x[i]) * (ny - y[i]) -
1LL * (y[j] - y[i]) * (nx - x[i]) ==
0;
}
bool cw(int i, int j, int nx, int ny) {
return 1LL * (x[j] - x[i]) * (ny - y[i]) -
1LL * (y[j] - y[i]) * (nx - x[i]) >=
0;
}
bool ccw(int i, int j, int nx, int ny) {
return 1LL * (x[j] - x[i]) * (ny - y[i]) -
1LL * (y[j] - y[i]) * (nx - x[i]) <=
0;
}
double solveX(int n) {
for (int i = -A; i <= A; ++i) {
up[i + A] = -2 * A;
down[i + A] = 2 * A;
}
bool ok1 = false, ok2 = false;
for (int i = 2; i < n; ++i)
if (!on(i - 2, i - 1, x[i], y[i])) {
ok1 = cw(i - 2, i - 1, x[i], y[i]);
ok2 = ccw(i - 2, i - 1, x[i], y[i]);
break;
}
for (int i = 0; i < n; ++i) {
int lx = min(x[i], x[i + 1]), rx = max(x[i], x[i + 1]);
if (lx == rx) {
up[lx + A] = max(up[lx + A], max(y[i], y[i + 1]));
down[lx + A] = min(down[lx + A], min(y[i], y[i + 1]));
} else
for (int j = lx; j <= rx; ++j) {
long double ny =
(1.0 * (y[i + 1] - y[i]) * (j - x[i]) / (x[i + 1] - x[i]));
int u = ny + y[i] - 2;
if (ok1) {
if (!cw(i, i + 1, j, u)) {
++u;
while (!cw(i, i + 1, j, u)) {
++u;
}
down[j + A] = u;
} else {
while (cw(i, i + 1, j, u + 1)) ++u;
up[j + A] = u;
}
}
if (ok2) {
if (!ccw(i, i + 1, j, u)) {
++u;
while (!ccw(i, i + 1, j, u)) {
++u;
}
down[j + A] = u;
} else {
while (ccw(i, i + 1, j, u + 1)) ++u;
up[j + A] = u;
}
}
}
}
long double ret = 0;
long long sum = 0, total = 0;
for (int i = -A; i <= A; ++i) {
if (up[i + A] >= down[i + A]) {
total += (up[i + A] - down[i + A] + 1);
ret += 1LL * i * i * (up[i + A] - down[i + A] + 1);
sum += 1LL * i * (up[i + A] - down[i + A] + 1);
}
}
for (int i = -A; i <= A; ++i) {
if (up[i + A] >= down[i + A]) {
ret -= 1.0 * i * (up[i + A] - down[i + A] + 1) / total * sum;
}
}
return ret / (total - 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d%d", &x[i], &y[i]);
x[n] = x[0];
y[n] = y[0];
double ans = solveX(n);
for (int i = 0; i <= n; ++i) swap(x[i], y[i]);
memset(up, 0, sizeof(up));
memset(down, 0, sizeof(down));
ans += solveX(n);
printf("%.7lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010000;
int x[110000], y[110000];
int n;
long double sumx2, sumx, sum;
long double sumy2, sumy;
long double l[N + 5], r[N + 5];
const long double dw = 1.;
inline void cover(int x1, int y1, int x2, int y2) {
if (x1 > x2) {
swap(x1, x2);
swap(y1, y2);
}
if (x1 == x2) {
l[x1] = min(l[x1], dw * min(y2, y1));
r[x1] = max(r[x1], dw * max(y2, y1));
} else {
for (int k = (x1); k <= (int)x2; k++) {
long double jiao = (y2 - y1) * ((k - x1) * dw / (x2 - x1)) + y1;
r[k] = max(r[k], jiao);
l[k] = min(l[k], jiao);
}
}
}
inline void Do() {
for (int i = (0); i <= (int)N; i++) l[i] = N, r[i] = 0;
for (int i = (1); i <= (int)n; i++) cover(x[i], y[i], x[i + 1], y[i + 1]);
for (int i = (0); i <= (int)N; i++)
if (l[i] < N - 2) {
int a1 = ceil(l[i]);
int a2 = (int)r[i];
long double ll = a1 * 1.;
long double rr = a2 * 1.;
sum += rr - ll + 1;
sumx += (rr - ll + 1) * i;
sumx2 += (rr - ll + 1) * 1. * i * i;
}
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (int)n; i++) {
scanf("%d%d", &x[i], &y[i]);
x[i] += N / 2;
y[i] += N / 2;
}
x[n + 1] = x[1];
y[n + 1] = y[1];
Do();
for (int i = (1); i <= (int)n + 1; i++) swap(x[i], y[i]);
sumy2 = sumx2;
sumy = sumx;
sumx2 = sumx = sum = 0;
Do();
long double ans = sum * sumx2 - sumx * sumx + sum * sumy2 - sumy * sumy;
ans /= sum;
ans /= (sum - 1);
printf("%.10lf\n", (double)ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
char ch;
inline void read(int &x) {
x = 0;
ch = getchar();
while (ch <= 32) ch = getchar();
int f = 1;
if (ch == '-') f = -1, ch = getchar();
while (ch > 32) x = x * 10 + ch - 48, ch = getchar();
x *= f;
}
template <class T>
inline void swap(T &a, T &b) {
T t = a;
a = b;
b = t;
}
template <class T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T min(T a, T b) {
return a < b ? a : b;
}
int n;
int X[100005], Y[100005];
int L[2000010], U[2000010];
inline int floordiv(long long a, int b) {
return a / b - (a < 0 && a % b != 0);
}
inline void add(int x1, int y1, int x2, int y2) {
if (x1 > x2) swap(x1, x2), swap(y1, y2);
if (x1 == x2) {
L[x1] = min(L[x1], min(y1, y2));
U[x1] = max(U[x1], max(y1, y2));
return;
}
int i;
for (i = x1; i <= x2; i++) {
int yU = floordiv(1LL * (i - x1) * (y2 - y1), (x2 - x1)) + y1;
int yL = yU + (1LL * (i - x1) * (y2 - y1) % (x2 - x1) != 0);
L[i] = min(L[i], yL);
U[i] = max(U[i], yU);
}
}
inline double calc() {
int i;
long long cnt = 0;
double sx = 0;
double sx2 = 0;
double ret = 0;
for (i = 1; i <= 2000005; i++) {
if (L[i] > U[i]) continue;
int k = U[i] - L[i] + 1;
ret += k * ((double)i * i * cnt + sx2 - 2.0 * i * sx);
sx += 1LL * k * i;
sx2 += 1LL * k * i * i;
cnt += k;
}
return ret / ((double)cnt * (cnt - 1));
}
inline double solvex() {
int i;
for (i = 1; i <= 2000005; i++) {
L[i] = 0x3f3f3f3f, U[i] = -0x3f3f3f3f;
}
for (i = 1; i <= n; i++) {
add(X[i], Y[i], X[i - 1], Y[i - 1]);
}
return calc();
}
inline double solvey() {
int i;
for (i = 1; i <= 2000005; i++) {
L[i] = 0x3f3f3f3f, U[i] = -0x3f3f3f3f;
}
for (i = 1; i <= n; i++) {
add(Y[i], X[i], Y[i - 1], X[i - 1]);
}
return calc();
}
int main() {
read(n);
int i;
for (i = 1; i <= n; i++) {
read(X[i]);
read(Y[i]);
X[i] += 1000003;
Y[i] += 1000003;
}
X[0] = X[n];
Y[0] = Y[n];
printf("%.10lf\n", solvex() + solvey());
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, x1, x2;
int x[100005], y[100005];
int l[3000005], r[3000005];
long long S[3000005], A, B, K;
double ans, sum, sum2, sum3;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i)
scanf("%d%d", &x[i], &y[i]), x[i] += 1000001, y[i] += 1000001;
for (i = 1; i <= 2000005; ++i) l[i] = 3000000, r[i] = -3000000;
x[n + 1] = x[1];
y[n + 1] = y[1];
for (i = 1; i <= n; ++i)
if (x[i] == x[i + 1]) {
if (y[i] > r[x[i]]) r[x[i]] = y[i];
if (y[i] - 1 < l[x[i]]) l[x[i]] = y[i] - 1;
if (y[i + 1] > r[x[i]]) r[x[i]] = y[i + 1];
if (y[i + 1] - 1 < l[x[i]]) l[x[i]] = y[i + 1] - 1;
} else {
if (x[i] < x[i + 1])
B = x[i + 1] - x[i], A = y[i] * B, K = y[i + 1] - y[i];
else
B = x[i] - x[i + 1], A = y[i + 1] * B, K = y[i] - y[i + 1];
x1 = x[i];
x2 = x[i + 1];
if (x1 > x2) swap(x1, x2);
for (j = x1; j <= x2; ++j) {
if (A / B > r[j]) r[j] = A / B;
if (A / B - (A % B == 0) < l[j]) l[j] = A / B - (A % B == 0);
A += K;
}
}
for (i = 1; i <= 2000005; ++i)
if (l[i] <= r[i]) ++S[l[i] + 1], --S[r[i] + 1];
for (i = 1; i <= 2000005; ++i) S[i] += S[i - 1];
sum = sum2 = sum3 = 0;
for (i = 1; i <= 2000005; ++i) {
ans += S[i] * (sum3 * i * i - sum2 * i * 2 + sum);
sum += (double)i * i * S[i];
sum2 += (double)i * S[i];
sum3 += S[i];
}
for (i = 1; i <= 2000005; ++i)
if (l[i] <= r[i])
S[i] = r[i] - l[i];
else
S[i] = 0;
sum = sum2 = sum3 = 0;
for (i = 1; i <= 2000005; ++i) {
ans += S[i] * (sum3 * i * i - sum2 * i * 2 + sum);
sum += (double)i * i * S[i];
sum2 += (double)i * S[i];
sum3 += S[i];
}
printf("%.20lf\n", ans / (sum3 * (sum3 - 1)));
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
double ans;
int n, m = 1000000;
int d[2000005], u[2000005];
int x[100005], y[100005];
void solve() {
for (int i = -m; i <= m; i++) d[i + m] = 1000000000, u[i + m] = -1000000000;
int lm = m, rm = -m;
for (int i = 1; i <= n; i++) lm = min(lm, x[i]), rm = max(rm, x[i]);
for (int i = 1; i <= n; i++) {
if (x[i] == x[i + 1]) {
u[x[i] + m] = max(u[x[i] + m], y[i]);
d[x[i] + m] = min(d[x[i] + m], y[i]);
continue;
}
bool flag = 0;
if (x[i] > x[i + 1]) {
swap(x[i], x[i + 1]), swap(y[i], y[i + 1]);
flag = 1;
}
for (int j = x[i]; j <= x[i + 1]; j++) {
double now =
(double)(j - x[i]) / (x[i + 1] - x[i]) * (y[i + 1] - y[i]) + y[i];
d[j + m] = min((int)ceil(now), d[j + m]);
u[j + m] = max((int)floor(now), u[j + m]);
}
if (flag) swap(x[i], x[i + 1]), swap(y[i], y[i + 1]);
}
double s0 = 0, s1 = 0, s2 = 0;
for (long long i = lm; i <= rm; i++) {
long long t = u[i + m] - d[i + m] + 1;
s0 += t;
s1 += t * i;
s2 += t * i * i;
}
ans += (double)(s0 * s2 - s1 * s1) / s0 / (s0 - 1);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) x[i] = read(), y[i] = read();
x[n + 1] = x[1];
y[n + 1] = y[1];
solve();
for (int i = 1; i <= n + 1; i++) swap(x[i], y[i]);
solve();
printf("%.10lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct ppp {
int x, y;
} p[370000];
long long num, res;
double ans;
int i, j, k, D[1000001 * 2 + 10], n, l, r, maxx;
void workx() {
num = 0;
res = 0;
k = n + 1;
maxx = p[1].x;
for (i = n + 2; i <= n + n; ++i) {
if (p[i].x < p[k].x) k = i;
maxx = max(maxx, p[i].x);
}
l = r = k;
for (i = p[k].x; i <= maxx; ++i) {
while (l - 1 >= 1 && p[l - 1].x >= p[l].x && p[l - 1].x <= i) --l;
while (r + 1 <= n * 3 && p[r + 1].x >= p[r].x && p[r + 1].x <= i) ++r;
double u =
double(p[l - 1].y - p[l].y) / (p[l - 1].x - p[l].x) * (i - p[l].x) +
p[l].y;
double d =
double(p[r + 1].y - p[r].y) / (p[r + 1].x - p[r].x) * (i - p[r].x) +
p[r].y;
if (u < d) swap(u, d);
D[i + 1000001] = int(floor(u) - ceil(d)) + 1;
num += D[i + 1000001];
res += (long long)i * D[i + 1000001];
}
for (j = p[k].x; j <= maxx; ++j) {
ans += double(num - 1) * j * j * D[j + 1000001];
ans -= double(res - j) * j * D[j + 1000001];
}
}
void worky() {
num = 0;
res = 0;
k = n + 1;
maxx = p[1].y;
for (i = n + 2; i <= n + n; ++i) {
if (p[i].y < p[k].y) k = i;
maxx = max(maxx, p[i].y);
}
l = r = k;
for (i = p[k].y; i <= maxx; ++i) {
while (l - 1 >= 1 && p[l - 1].y >= p[l].y && p[l - 1].y <= i) --l;
while (r + 1 <= n * 3 && p[r + 1].y >= p[r].y && p[r + 1].y <= i) ++r;
double u =
double(p[l - 1].x - p[l].x) / (p[l - 1].y - p[l].y) * (i - p[l].y) +
p[l].x;
double d =
double(p[r + 1].x - p[r].x) / (p[r + 1].y - p[r].y) * (i - p[r].y) +
p[r].x;
if (u < d) swap(u, d);
D[i + 1000001] = int(floor(u) - ceil(d)) + 1;
num += D[i + 1000001];
res += (long long)i * D[i + 1000001];
}
for (j = p[k].y; j <= maxx; ++j) {
ans += double(num - 1) * j * j * D[j + 1000001];
ans -= double(res - j) * j * D[j + 1000001];
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d%d", &p[i].x, &p[i].y);
p[i + n] = p[i + n + n] = p[i];
}
p[0] = p[n];
p[n + n + n + 1] = p[1];
workx();
worky();
printf("%.10lf\n", ans / num / (num - 1));
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x[100000], y[100000];
double solve(int* x, int* y, int n) {
long long area = 0;
for (int i = 0; i < n; i++) {
long long ax = x[i], bx = x[(i + 1) % n];
long long ay = y[i], by = y[(i + 1) % n];
area += ax * by - ay * bx;
}
if (area > 0) {
reverse(x, x + n);
reverse(y, y + n);
}
vector<long long> count(2e6 + 10, 0);
long long maxx = -1e9;
for (int i = 0; i < n; i++) {
long long ax = x[i], bx = x[(i + 1) % n];
long long ay = y[i], by = y[(i + 1) % n];
for (int j = ax; j < bx; j++) {
count[j] += (ay * (bx - ax) + (by - ay) * (j - ax)) / (bx - ax);
}
for (int j = bx; j < ax; j++) {
count[j] -= (by * (ax - bx) + (ay - by) * (j - bx) - 1) / (ax - bx);
}
if (ax == bx && by < ay) {
count[ax] += ay - by;
}
maxx = max(maxx, ax);
}
count[maxx]++;
long double sum = 0, sum2 = 0, tot = 0;
for (int i = 0; i < count.size(); i++) {
tot += count[i];
sum += (long double)count[i] * i;
}
assert(tot > 1);
sum /= tot;
for (int i = 0; i < count.size(); i++) {
sum2 += count[i] * (i - sum) * (i - sum);
}
return 2 * sum2 / (tot - 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
x[i] += 1e6 + 1;
y[i] += 1e6 + 1;
}
double ans = 0;
ans += solve(x, y, n);
ans += solve(y, x, n);
cout << setprecision(20) << ans / 2 << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[100005];
int crossProd(pair<int, int> o, pair<int, int> a, pair<int, int> b) {
long long res = 1ll * (a.first - o.first) * (b.second - o.second) -
1ll * (a.second - o.second) * (b.first - o.first);
if (res > 0) return 1;
if (res == 0) return 0;
return -1;
}
struct hull {
set<pair<int, int> > s;
bool checkUnder(const pair<int, int>& p) {
if (s.empty()) return 0;
if (p.first < (*s.begin()).first || (*s.rbegin()).first < p.first) return 0;
set<pair<int, int> >::iterator it =
s.lower_bound(pair<int, int>(p.first, -(int)1e9));
if ((*it).first == p.first) return (*it).second >= p.second;
return crossProd(*prev(it), *it, p) <= 0;
};
void insert(const pair<int, int>& p) {
set<pair<int, int> >::iterator it =
s.lower_bound(pair<int, int>(p.first, -(int)1e9));
if (it != s.end() && (*it).first == p.first) {
if ((*it).second >= p.second)
return;
else
s.erase(it);
}
s.insert(p);
set<pair<int, int> >::iterator ppos = s.find(p);
if (ppos != s.begin() && next(ppos) != s.end()) {
pair<int, int> bef = *(prev(ppos));
pair<int, int> aft = *(next(ppos));
if (crossProd(bef, p, aft) >= 0) {
s.erase(ppos);
return;
}
}
while (next(ppos) != s.end() && next(next(ppos)) != s.end() &&
crossProd(p, *next(ppos), *next(next(ppos))) >= 0) {
s.erase(next(ppos));
}
while (ppos != s.begin() && prev(ppos) != s.begin() &&
crossProd(*prev(prev(ppos)), *prev(ppos), p) >= 0) {
s.erase(prev(ppos));
}
};
};
long long total = 0;
hull up, down;
int cnt[2000005];
long double solve() {
up.s.clear();
down.s.clear();
int minx = (int)1e6, maxx = (int)-1e6;
for (int i = 0; i < n; i++) {
minx = min(minx, a[i].first);
maxx = max(maxx, a[i].first);
up.insert(pair<int, int>(a[i].first, a[i].second));
down.insert(pair<int, int>(a[i].first, -a[i].second));
}
int pivotup = (int)1e6;
int pivotdown = (int)1e6;
for (int i = minx; i <= maxx; i++) {
while (!up.checkUnder(pair<int, int>(i, pivotup))) pivotup--;
while (up.checkUnder(pair<int, int>(i, pivotup + 1))) pivotup++;
while (!down.checkUnder(pair<int, int>(i, pivotdown))) pivotdown--;
while (down.checkUnder(pair<int, int>(i, pivotdown + 1))) pivotdown++;
cnt[i + (int)1e6] = max(0, pivotup - (-pivotdown) + 1);
total += cnt[i + (int)1e6];
}
long double res = 0;
long double sumaj = 0, sumajj = 0, sumajjj = 0;
for (int i = minx; i <= maxx; i++) {
res += 1.0 * cnt[i + (int)1e6] *
(1.0 * sumaj * i * i + sumajjj - 2.0 * i * sumajj);
sumaj += 1.0 * cnt[i + (int)1e6];
sumajj += 1.0 * cnt[i + (int)1e6] * i;
sumajjj += 1.0 * cnt[i + (int)1e6] * i * i;
}
return res;
}
int main() {
iostream::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
long double ans = solve();
for (int i = 0; i < n; i++) swap(a[i].first, a[i].second);
ans += solve();
total /= 2;
cout << fixed << setprecision(10)
<< ans / 2 / (1.0 * total * (total - 1) / 2);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> p[100010], up[100010], down[100010];
double ans;
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
long long cp(pair<int, int> A, pair<int, int> B, pair<int, int> C) {
return (long long)(B.first - A.first) * (C.second - A.second) -
(long long)(C.first - A.first) * (B.second - A.second);
}
int GetU(pair<int, int> *a, int tot, int x) {
int t = upper_bound(a + 1, a + tot + 1, make_pair(x, 1000000)) - a - 1;
if (a[t].first == x) return a[t].second;
int tmp = (double)(a[t + 1].second - a[t].second) /
(a[t + 1].first - a[t].first) * (x - a[t].first) +
a[t].second;
for (int i = tmp + 1;; i--)
if (cp(a[t], make_pair(x, i), a[t + 1]) >= 0) return i;
}
int GetD(pair<int, int> *a, int tot, int x) {
int t = upper_bound(a + 1, a + tot + 1, make_pair(x, 1000000)) - a - 1;
if (a[t].first == x) return a[t].second;
int tmp = (double)(a[t + 1].second - a[t].second) /
(a[t + 1].first - a[t].first) * (x - a[t].first) +
a[t].second;
for (int i = tmp - 1;; i++)
if (cp(a[t], make_pair(x, i), a[t + 1]) <= 0) return i;
}
double Solve() {
double X1 = 0, X2 = 0, Y = 0;
int st = 0, en = 0, utot = 0, dtot = 0;
for (int i = 1; i <= n; i++) {
if (st == 0 || p[st].first > p[i].first ||
(p[st].first == p[i].first && p[st].second < p[i].second))
st = i;
if (en == 0 || p[en].first < p[i].first ||
(p[en].first == p[i].first && p[en].second < p[i].second))
en = i;
}
if (cp(p[st], p[((st == n) ? 1 : st + 1)], p[((st == 1) ? n : st - 1)]) < 0)
for (int i = st; i != en; i = ((i == n) ? 1 : i + 1)) up[++utot] = p[i];
else
for (int i = st; i != en; i = ((i == 1) ? n : i - 1)) up[++utot] = p[i];
up[++utot] = p[en];
st = en = 0;
for (int i = 1; i <= n; i++) {
if (st == 0 || p[st].first > p[i].first ||
(p[st].first == p[i].first && p[st].second > p[i].second))
st = i;
if (en == 0 || p[en].first < p[i].first ||
(p[en].first == p[i].first && p[en].second > p[i].second))
en = i;
}
if (cp(p[st], p[((st == n) ? 1 : st + 1)], p[((st == 1) ? n : st - 1)]) > 0)
for (int i = st; i != en; i = ((i == n) ? 1 : i + 1)) down[++dtot] = p[i];
else
for (int i = st; i != en; i = ((i == 1) ? n : i - 1)) down[++dtot] = p[i];
down[++dtot] = p[en];
for (int i = p[st].first; i <= p[en].first; i++) {
int U = GetU(up, utot, i), D = GetD(down, dtot, i);
Y += U - D + 1;
X2 += (long long)(U - D + 1) * i;
X1 += (long long)(U - D + 1) * i * i;
}
return (2 * X1 * (Y - 1) - 2 * (X2 * X2 - X1)) / Y / (Y - 1) / 2;
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(p[i].first), read(p[i].second);
ans = Solve();
for (int i = 1; i <= n; i++) swap(p[i].first, p[i].second);
ans += Solve();
printf("%.9lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010, MAXV = 1000010;
const double eps = 1e-8, PI = atan2(0, -1);
vector<double> x[MAXV * 2], y[MAXV * 2];
int cx[MAXV * 2], cy[MAXV * 2];
inline double sqr(double x) { return x * x; }
inline bool zero(double x) { return (x > 0 ? x : -x) < eps; }
inline int sgn(double x) { return (x > eps ? 1 : (x + eps < 0 ? -1 : 0)); }
struct point {
double x, y;
point(double x, double y) : x(x), y(y) {}
point() {}
bool operator==(const point& a) const {
return sgn(x - a.x) == 0 && sgn(y - a.y) == 0;
}
bool operator!=(const point& a) const {
return sgn(x - a.x) != 0 || sgn(y - a.y) != 0;
}
bool operator<(const point& a) const {
return sgn(x - a.x) < 0 || sgn(x - a.x) == 0 && sgn(y - a.y) < 0;
}
point operator+(const point& a) const { return point(x + a.x, y + a.y); }
point operator-(const point& a) const { return point(x - a.x, y - a.y); }
point operator*(const double& a) const { return point(x * a, y * a); }
point operator/(const double& a) const { return point(x / a, y / a); }
double operator*(const point& a) const { return x * a.y - y * a.x; }
double operator^(const point& a) const { return x * a.x + y * a.y; }
} p[MAXN], tp[3];
inline bool dotsInline(const point& p1, const point& p2, const point& p3) {
return zero((p1 - p3) * (p2 - p3));
}
inline bool parallel(const point& u1, const point& u2, const point& v1,
const point& v2) {
return zero((u1 - u2) * (v1 - v2));
}
inline point intersection(const point& u1, const point& u2, const point& v1,
const point& v2) {
return u1 + (u2 - u1) * (((u1 - v1) * (v1 - v2)) / ((u1 - u2) * (v1 - v2)));
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &p[i].x, &p[i].y);
p[i].x += MAXV;
p[i].y += MAXV;
}
p[n] = p[0];
for (int i = 0; i < n; i++) {
if (p[i].x < p[i + 1].x) {
for (int j = p[i].x; j <= p[i + 1].x; j++) {
tp[0] = point(j, 0);
tp[1] = point(j, 1);
if (!parallel(tp[0], tp[1], p[i], p[i + 1])) {
x[j].push_back(intersection(tp[0], tp[1], p[i], p[i + 1]).y);
}
}
} else if (p[i].x > p[i + 1].x) {
for (int j = p[i + 1].x; j <= p[i].x; j++) {
tp[0] = point(j, 0);
tp[1] = point(j, 1);
if (!parallel(tp[0], tp[1], p[i], p[i + 1])) {
x[j].push_back(intersection(tp[0], tp[1], p[i], p[i + 1]).y);
}
}
} else {
x[int(p[i].x + .2)].push_back(p[i].y);
x[int(p[i].x + .2)].push_back(p[i + 1].y);
}
if (p[i].y < p[i + 1].y) {
for (int j = p[i].y; j <= p[i + 1].y; j++) {
tp[0] = point(0, j);
tp[1] = point(1, j);
if (!parallel(tp[0], tp[1], p[i], p[i + 1])) {
y[j].push_back(intersection(tp[0], tp[1], p[i], p[i + 1]).x);
}
}
} else if (p[i].y > p[i + 1].y) {
for (int j = p[i + 1].y; j <= p[i].y; j++) {
tp[0] = point(0, j);
tp[1] = point(1, j);
if (!parallel(tp[0], tp[1], p[i], p[i + 1])) {
y[j].push_back(intersection(tp[0], tp[1], p[i], p[i + 1]).x);
}
}
} else {
y[int(p[i].y + .2)].push_back(p[i].x);
y[int(p[i].y + .2)].push_back(p[i + 1].x);
}
}
int lowx = MAXV * 2 - 1, highx = 0;
long long tot = 0;
for (int i = 0; i < MAXV * 2; i++) {
if (x[i].size() == 0) continue;
lowx = min(lowx, i);
highx = max(highx, i);
double l = x[i][0], r = x[i][0];
for (int j = 0; j < (int)x[i].size(); j++) {
l = min(x[i][j], l);
r = max(x[i][j], r);
}
int L = (int)l - 2, R = (int)r + 2;
while (sgn(L - l) < 0) L++;
while (sgn(r - R) < 0) R--;
cx[i] = R - L + 1;
tot += cx[i];
}
double mul = (2.0 / tot) / (tot - 1);
int lowy = MAXV * 2 - 1, highy = 0;
for (int i = 0; i < MAXV * 2; i++) {
if (y[i].size() == 0) continue;
lowy = min(lowy, i);
highy = max(highy, i);
double l = y[i][0], r = y[i][0];
for (int j = 0; j < (int)y[i].size(); j++) {
l = min(y[i][j], l);
r = max(y[i][j], r);
}
int L = (int)l - 2, R = (int)r + 2;
while (sgn(L - l) < 0) L++;
while (sgn(r - R) < 0) R--;
cy[i] = R - L + 1;
}
double A = cx[highx], B = cx[highx], C = 0;
double ans = A * (cx[highx - 1] * mul);
for (int i = highx - 1; i > lowx; i--) {
C += 2 * cx[i + 1];
B += C + cx[i];
A += B;
ans += A * (cx[i - 1] * mul);
}
A = cy[highy];
B = cy[highy];
C = 0;
ans += A * (cy[highy - 1] * mul);
for (int i = highy - 1; i > lowy; i--) {
C += 2 * cy[i + 1];
B += C + cy[i];
A += B;
ans += A * (cy[i - 1] * mul);
}
printf("%.20lf\n", ans * .5);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
int x[100010], y[100010], n, cnt[1000010 << 1];
double ans;
double solve() {
double area = 0;
x[n] = x[0], y[n] = y[0];
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < n; ++i)
area += (1. * x[i] * y[i + 1]) - (1. * y[i] * x[i + 1]);
if (area < 0) {
reverse(x, x + n), reverse(y, y + n);
}
x[n] = x[0], x[n + 1] = x[1];
y[n] = y[0], y[n + 1] = y[1];
for (int i = 0; i < n; ++i) {
if (x[i] < x[i + 1]) {
double k = 1. * (y[i + 1] - y[i]) / (x[i + 1] - x[i]);
for (int j = x[i]; j < x[i + 1]; ++j)
cnt[j] -= floor(y[i] + k * (j - x[i]) - 1e-8);
if (x[i + 1] >= x[i + 2]) cnt[x[i + 1]] -= y[i + 1] - 1;
}
if (x[i] > x[i + 1]) {
double k = 1. * (y[i + 1] - y[i]) / (x[i + 1] - x[i]);
for (int j = x[i]; j > x[i + 1]; --j)
cnt[j] += floor(y[i] + k * (j - x[i]) + 1e-8);
if (x[i + 1] <= x[i + 2]) cnt[x[i + 1]] += y[i + 1];
}
}
double s1 = 0, s2 = 0, s0 = 0;
for (int i = 0; i < (1000010 << 1); ++i) {
s0 += 1. * cnt[i];
s1 += 1. * cnt[i] * i;
s2 += 1. * cnt[i] * i * i;
}
return (2.0 * s0 * s2 - 2.0 * s1 * s1) / s0 / (s0 - 1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i], &y[i]);
x[i] += 1000010, y[i] += 1000010;
}
ans = 0;
ans += solve();
for (int i = 0; i < n; ++i) swap(x[i], y[i]);
ans += solve();
printf("%.9f\n", ans / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, i, x[100020], y[100020], c[2000010], low, high, kol[2000010], j;
double a1, b1, c1, a2, b2, c2, nx2, all, all2, ans, a[2000010][6];
void buildLine(double x1, double y1, double x2, double y2, double& a, double& b,
double& c) {
a = y2 - y1;
b = x1 - x2;
c = -a * x1 - b * y1;
}
void Solve() {
for (i = 1; i <= n; i++) {
buildLine(x[i], y[i], x[i + 1], y[i + 1], a1, b1, c1);
if (x[i] != x[i + 1])
for (j = min(x[i], x[i + 1]); j <= max(x[i], x[i + 1]); j++) {
buildLine(j, 0, j, 1, a2, b2, c2);
nx2 = -(1.0 * a1 * 1.0 * c2 - 1.0 * a2 * c1 * 1.0) /
(1.0 * a1 * 1.0 * b2 - 1.0 * a2 * 1.0 * b1);
a[j][++c[j]] = nx2;
}
}
for (i = 0; i <= 2000000; i++)
if (c[i]) {
sort(a[i] + 1, a[i] + c[i] + 1);
low = ceil(a[i][1] - 1e-9);
high = floor(a[i][c[i]] + 1e-9);
kol[i] = high - low + 1;
all += kol[i];
all2 += kol[i] * 1.0 * i;
}
for (i = 0; i <= 2000000; i++)
if (c[i]) {
ans += 1.0 * kol[i] * 1.0 * i * 1.0 * i * (1.0 * all - 1.0 * kol[i]);
ans -= 1.0 * kol[i] * 1.0 * i * (all2 - kol[i] * 1.0 * i);
}
}
int main(int argc, char* const argv[]) {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &x[i], &y[i]);
x[i] += 1000000;
y[i] += 1000000;
}
x[n + 1] = x[1];
y[n + 1] = y[1];
Solve();
for (i = 1; i <= n + 1; i++) swap(x[i], y[i]);
all = all2 = 0;
for (i = 0; i <= 2000000; i++) c[i] = kol[i] = 0;
Solve();
printf("%.10lf\n", ans / (1.0 * all * (all - 1)));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int SIZEN = 200010;
const long long INF = 1e10;
class Point {
public:
long long x, y;
};
void print(const Point &p) { cout << "(" << p.x << " " << p.y << ")"; }
long long cross(const Point &a, const Point &b) {
return a.x * b.y - b.x * a.y;
}
int N;
Point P[SIZEN];
double calc_cut(const Point &a, const Point &b, long long x) {
return a.y + (b.y - a.y) * (x - a.x + 0.0) / (b.x - a.x);
}
double solve(void) {
long long L = INF, R = -INF;
for (int i = 1; i <= N; i++) {
L = min(L, P[i].x);
R = max(R, P[i].x);
}
double S0 = 0, S1 = 0, S2 = 0;
int ld = 1;
for (int i = 2; i <= N; i++)
if (P[i].x < P[ld].x || (P[i].x == P[ld].x && P[i].y < P[ld].y)) ld = i;
for (long long x = L; x <= R; x++) {
while (P[ld].x < x) ld++;
double y;
if (P[ld].x == x)
y = P[ld].y - 1;
else
y = ceil(calc_cut(P[ld - 1], P[ld], x)) - 1;
S0 -= y;
S1 -= y * x;
S2 -= y * x * x;
}
int lu = 1;
for (int i = 2; i <= N; i++)
if (P[i].x < P[lu].x || (P[i].x == P[lu].x && P[i].y > P[lu].y)) lu = i;
lu += N;
for (long long x = L; x <= R; x++) {
while (P[lu].x < x) lu--;
double y;
if (P[lu].x == x)
y = P[lu].y;
else
y = floor(calc_cut(P[lu + 1], P[lu], x));
S0 += y;
S1 += y * x;
S2 += y * x * x;
}
return (S2 * S0 - S1 * S1) / S0 / (S0 - 1);
}
void init(void) {
scanf("%d", &N);
long long area = 0;
for (int i = 1; i <= N; i++) {
scanf("%I64d%I64d", &P[i].x, &P[i].y);
P[i + N] = P[i];
}
for (int i = 1; i <= N; i++) area += cross(P[i], P[i + 1]);
if (area < 0) reverse(P + 1, P + 1 + 2 * N);
}
int main() {
init();
double ans = 0;
ans += solve();
for (int i = 1; i <= 2 * N; i++) swap(P[i].x, P[i].y);
reverse(P + 1, P + 1 + 2 * N);
ans += solve();
printf("%.10lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int SIZEN = 200010;
const long long INF = 1e10;
class Point {
public:
long long x, y;
};
void print(const Point &p) { cout << "(" << p.x << " " << p.y << ")"; }
long long cross(const Point &a, const Point &b) {
return a.x * b.y - b.x * a.y;
}
int N;
Point P[SIZEN];
double calc_cut(const Point &a, const Point &b, long long x) {
return a.y + (b.y - a.y) * (x - a.x + 0.0) / (b.x - a.x);
}
double solve(void) {
long long L = INF, R = -INF;
for (int i = 1; i <= N; i++) {
L = min(L, P[i].x);
R = max(R, P[i].x);
}
double S0 = 0, S1 = 0, S2 = 0;
int ld = 1;
for (int i = 2; i <= N; i++)
if (P[i].x < P[ld].x || (P[i].x == P[ld].x && P[i].y < P[ld].y)) ld = i;
for (long long x = L; x <= R; x++) {
while (P[ld].x < x) ld++;
double y;
if (P[ld].x == x)
y = P[ld].y - 1;
else
y = ceil(calc_cut(P[ld - 1], P[ld], x)) - 1;
S0 -= y;
S1 -= y * x;
S2 -= y * x * x;
}
int lu = 1;
for (int i = 2; i <= N; i++)
if (P[i].x < P[lu].x || (P[i].x == P[lu].x && P[i].y > P[lu].y)) lu = i;
lu += N;
for (long long x = L; x <= R; x++) {
while (P[lu].x < x) lu--;
double y;
if (P[lu].x == x)
y = P[lu].y;
else
y = floor(calc_cut(P[lu + 1], P[lu], x));
S0 += y;
S1 += y * x;
S2 += y * x * x;
}
return (S2 * S0 - S1 * S1) / S0 / (S0 - 1);
}
void init(void) {
scanf("%d", &N);
long long area = 0;
for (int i = 1; i <= N; i++) {
scanf("%I64d%I64d", &P[i].x, &P[i].y);
P[i + N] = P[i];
}
for (int i = 1; i <= N; i++) area += cross(P[i], P[i + 1]);
if (area < 0) reverse(P + 1, P + 1 + 2 * N);
}
int main() {
init();
double ans = 0;
ans += solve();
for (int i = 1; i <= 2 * N; i++) swap(P[i].x, P[i].y);
reverse(P + 1, P + 1 + 2 * N);
ans += solve();
printf("%.10lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline int dec(int a, int b) {
if ((a -= b) < 0) a += mod;
return a;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
inline int power(int a, int b) {
int out = 1;
while (b) {
if (b & 1) out = mult(out, a);
a = mult(a, a);
b >>= 1;
}
return out;
}
const double eps = 1e-8;
class Point {
public:
int x, y;
} d[200005];
long double ans, s2, s1, s0;
int n;
inline void work() {
int t = 1, l = 1, r = n + 1;
s2 = s1 = s0 = 0;
for (int i = 1; i <= n; i++)
if (d[i].x < d[t].x) t = i;
for (int i = 1; i < t; i++) d[i + n] = d[i];
for (int i = 1; i <= n; i++) d[i] = d[i + t - 1];
while (d[l + 1].x == d[1].x) l++;
while (d[r - 1].x == d[1].x) r--;
l++;
r--;
d[n + 1] = d[1];
for (int x = d[1].x;; x++) {
while (d[l].x < x && l <= r) l++;
if (l > r) break;
while (d[r].x < x) r--;
double ly = ((double)d[l].y - d[l - 1].y) / (d[l].x - d[l - 1].x) *
(x - d[l - 1].x) +
d[l - 1].y;
double ry = ((double)d[r].y - d[r + 1].y) / (d[r].x - d[r + 1].x) *
(x - d[r + 1].x) +
d[r + 1].y;
if (ly > ry) swap(ly, ry);
ans += s2 * (floor(ry + eps) - ceil(ly - eps) + 1);
s0 += floor(ry + eps) - ceil(ly - eps) + 1;
s1 += s0;
s2 += s1 * 2 - s0;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &d[i].x, &d[i].y);
work();
for (int i = 1; i <= n; i++) d[i].x = -d[i].x;
work();
for (int i = 1; i <= n; i++) swap(d[i].x, d[i].y);
work();
for (int i = 1; i <= n; i++) d[i].x = -d[i].x;
work();
printf("%.15Lf\n", (ans * 0.5 / (s0 * s0 - s0)));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x[2100000], y[2100000], n, Min[2100000], Max[2100000];
long long s[2100000];
double ans = 0, p[2100000], sum1[2100000], sum2[2100000];
void solved() {
int m = 0;
for (int i = 1; i <= n; i++) m = max(m, x[i]);
x[n + 1] = x[1];
y[n + 1] = y[1];
for (int i = 1; i <= m; i++) Min[i] = 1000000000, Max[i] = 0;
for (int i = 1; i <= n; i++) {
int t1 = x[i], t2 = x[i + 1], t3 = y[i], t4 = y[i + 1];
if (t1 > t2) swap(t1, t2), swap(t3, t4);
if (t1 == t2) {
Min[t1] = min(Min[t1], t3);
Max[t1] = max(Max[t1], t3);
Min[t1] = min(Min[t1], t4);
Max[t1] = max(Max[t1], t4);
continue;
}
for (int j = t1; j <= t2; j++) {
double y =
(double)(t2 - j) * t3 / (t2 - t1) + (double)(j - t1) * t4 / (t2 - t1);
Max[j] = max(Max[j], (int)floor(y + 1e-9));
Min[j] = min(Min[j], (int)ceil(y - 1e-9));
}
}
for (int i = 1; i <= m; i++) s[i] = Max[i] - Min[i] + 1 + s[i - 1];
for (int i = 1; i <= m; i++) {
p[i] = (double)(s[i] - s[i - 1]) / (s[m] - 1);
sum1[i] = p[i] * i;
sum2[i] = p[i] * i * i;
sum1[i] += sum1[i - 1];
sum2[i] += sum2[i - 1];
p[i] += p[i - 1];
}
for (int i = 1; i <= m; i++) {
double pp = (double)(s[i] - s[i - 1]) / s[m];
ans += pp * i * i * (p[i - 1] + p[m] - p[i]) +
(sum2[m] - sum2[i] + sum2[i - 1]) * pp -
2 * (sum1[m] - sum1[i] + sum1[i - 1]) * i * pp;
}
}
int main() {
scanf("%d", &n);
int minx = 1000000000, miny = 1000000000;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x[i], &y[i]);
minx = min(minx, x[i]);
miny = min(miny, y[i]);
}
minx--;
miny--;
for (int i = 1; i <= n; i++) x[i] -= minx, y[i] -= miny;
solved();
for (int i = 1; i <= n; i++) swap(x[i], y[i]);
solved();
printf("%.8lf\n", ans / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> p[300000];
int freq[2][10 * 300000];
long long num = 0;
vector<int> mx, my;
void update(int p1) {
if (mx.empty()) {
mx.push_back(p1);
my.push_back(p1);
return;
}
if (p[mx[0]].first == p[p1].first) {
mx.push_back(p1);
} else if (p[mx[0]].first < p[p1].first) {
mx.clear();
mx.push_back(p1);
}
if (p[my[0]].second == p[p1].second)
my.push_back(p1);
else if (p[my[0]].second < p[p1].second) {
my.clear();
my.push_back(p1);
}
}
double get_y(int first, pair<int, int> p1, pair<int, int> p2) {
if (p1.first == p2.first) return p1.second;
return 1.0 * (first - p2.first) / (p1.first - p2.first) *
(p1.second - p2.second) +
p2.second;
}
double get_x(int second, pair<int, int> p1, pair<int, int> p2) {
if (p1.second == p2.second) return p1.first;
return 1.0 * (second - p2.second) / (p1.second - p2.second) *
(p1.first - p2.first) +
p2.first;
}
void walk_x() {
int lo, hi;
if (mx.size() == 1) {
lo = mx[0];
hi = mx[0];
} else {
lo = mx[0];
hi = mx[1];
if (lo == 0 && hi == n - 1) swap(lo, hi);
}
for (int first = p[lo].first;; first--) {
if (first < p[lo].first) lo = (lo + n - 1) % n;
if (first < p[lo].first) break;
if (first < p[hi].first) hi = (hi + 1) % n;
if (first < p[hi].first) break;
double y1 = get_y(first, p[lo], p[(lo + 1) % n]);
double y2 = get_y(first, p[hi], p[(hi + n - 1) % n]);
if (y2 < y1) swap(y1, y2);
int yy1 = ceil(y1 - 1e-9);
int yy2 = floor(y2 + 1e-9);
freq[0][first + 1000000] = yy2 - yy1 + 1;
}
}
void walk_y() {
int lo, hi;
if (my.size() == 1) {
lo = my[0];
hi = my[0];
} else {
lo = my[0];
hi = my[1];
if (lo == 0 && hi == n - 1) swap(lo, hi);
}
for (int second = p[lo].second;; second--) {
if (second < p[lo].second) lo = (lo + n - 1) % n;
if (second < p[lo].second) break;
if (second < p[hi].second) hi = (hi + 1) % n;
if (second < p[hi].second) break;
double x1 = get_x(second, p[lo], p[(lo + 1) % n]);
double x2 = get_x(second, p[hi], p[(hi + n - 1) % n]);
if (x2 < x1) swap(x1, x2);
int xx1 = ceil(x1 - 1e-9);
int xx2 = floor(x2 + 1e-9);
freq[1][second + 1000000] = xx2 - xx1 + 1;
}
}
double get_ans() {
double tot = 0;
double sum[2] = {0, 0};
for (int i = -1000000; i <= 1000000; i++) {
num += freq[0][i + 1000000];
}
for (int i = -1000000; i <= 1000000; i++) {
for (int j = 0; j < 2; j++) {
tot += 1.0 * freq[j][i + 1000000] * i * i * num;
sum[j] += 1.0 * i * freq[j][i + 1000000];
}
}
tot -= sum[0] * sum[0] + sum[1] * sum[1];
tot /= num;
tot /= num - 1;
return tot;
}
int main() {
memset(freq, 0, sizeof(freq));
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &p[i].first, &p[i].second);
update(i);
}
walk_x();
walk_y();
printf("%.10f\n", get_ans());
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long double x, y;
inline Point(long double xx = 0, long double yy = 0) : x(xx), y(yy) {}
inline void read() {
double x0 = 0, y0 = 0;
scanf("%lf%lf", &x0, &y0);
x = x0 + 1000000;
y = y0 + 1000000;
}
inline long double operator*(const Point &A) const {
return x * A.y - y * A.x;
}
inline Point operator+(const Point &A) const {
return Point(x + A.x, y + A.y);
}
inline Point operator-(const Point &A) const {
return Point(x - A.x, y - A.y);
}
inline int operator<(const Point &A) const {
if (x != A.x) return x < A.x;
return y < A.y;
}
} P[100005];
int dA, dB, A, B, c, vis[100005], n;
long double sy, sy2, sx, sx2, num, ans;
inline int next(int x) {
x++;
if (x > n) x = 1;
return x;
}
inline int prev(int x) {
--x;
if (x < 1) x = n;
return x;
}
inline long double ask(int A, int B, int x) {
if (P[B].x == P[A].x) return P[B].y;
long double lamda = (x - P[A].x) / (P[B].x - P[A].x);
return lamda * (P[B].y - P[A].y) + P[A].y;
}
inline long double ask(long double x) {
if (x <= 0) return 0;
return x * (x + 1) * (2 * x + 1) / 6.0;
}
int Max;
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) P[i].read();
c = 1;
for (int i = (2); i <= (n); i++)
if (P[i] < P[c]) c = i;
for (int i = (1); i <= (n); i++)
if (P[i].x > Max) Max = P[i].x;
A = next(c);
B = prev(c);
dA = dB = c;
vis[dA] = 1;
for (long double Nowx = P[c].x; Nowx <= Max; Nowx++) {
long double uy = ask(dA, A, Nowx), dy = ask(dB, B, Nowx);
if (uy < dy) swap(uy, dy);
long double Uy = floor(uy), Dy = ceil(dy);
num += Uy - Dy + 1;
sx += Nowx * (Uy - Dy + 1);
sx2 += Nowx * Nowx * (Uy - Dy + 1);
sy += (Dy + Uy) * (Uy - Dy + 1) / 2.0;
sy2 += ask(Uy) - ask(Dy - 1);
if (Nowx == P[A].x) {
dA = A;
vis[dA] = 1;
int cho1 = prev(dA), cho2 = next(dA);
if (vis[cho1])
A = cho2;
else
A = cho1;
}
if (Nowx == P[B].x) {
dB = B;
vis[dB] = 1;
int cho1 = prev(dB), cho2 = next(dB);
if (vis[cho1])
B = cho2;
else
B = cho1;
}
}
ans += (num)*sx2 - sx * sx;
ans += (num)*sy2 - sy * sy;
ans /= num;
ans /= (num - 1);
printf("%.12lf\n", double(ans));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
pair<int, int> A[1000005];
int N;
void Init() {
Get(N);
for (int i = 1; i <= N; i++) {
Get(A[i].first);
Get(A[i].second);
A[i].first += 1000005;
A[i].second += 1000005;
}
}
double Floor(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) *
(A[Y].second - A[X].second) /
(double)(A[Y].first - A[X].first);
return floor(Y1 + (1e-8));
}
double Ceil(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) *
(A[Y].second - A[X].second) /
(double)(A[Y].first - A[X].first);
return ceil(Y1 - (1e-8));
}
long double F[10000005];
long double Ans;
void Calc() {
rotate(A + 1, min_element(A + 1, A + N + 1), A + N + 1);
A[N + 1] = A[1];
int Pos = max_element(A + 1, A + N + 1) - A;
int P = A[1].first, Q = A[Pos].first;
for (int i = P, k = 1; i <= Q; i++) {
for (; A[k + 1].first < i;) k++;
int Pos = Ceil(k, k + 1, i);
F[i] = -Pos + 1;
}
long double Cnt = 0;
long double SumX = 0;
for (int i = Q, k = Pos; i >= P; i--) {
for (; A[k + 1].first > i;) k++;
int Pos = Floor(k, k + 1, i);
F[i] += Pos;
Cnt += F[i];
SumX += (i - 1000005) * F[i];
}
for (int i = Q; i >= P; i--)
Ans += F[i] * (i - 1000005) * (i - 1000005) / (Cnt - 1);
Ans -= SumX * SumX / ((Cnt - 1) * Cnt);
}
void Work() {
long long S = 0;
A[N + 1] = A[1];
for (int k = 1; k <= N + 1; k++)
S += A[k].first * A[k + 1].second - A[k].second * A[k + 1].first;
if (S < 0) reverse(A + 1, A + N + 1);
Calc();
for (int k = 1; k <= N; k++) std::swap(A[k].first, A[k].second);
reverse(A + 1, A + N + 1);
Calc();
}
void Output() { printf("%.15lf\n", (double)Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N;
long long x[100000];
long long y[100000];
int cntx[3000000];
long long sm0[3000000];
double sm1[3000000];
double sm2[3000000];
double ans;
long long tot;
void addTop(int i, int i2, bool skipStart) {
for (long long cx = x[i] + skipStart; cx <= x[i2]; cx++) {
long long cy = (y[i] * (x[i2] - cx) + y[i2] * (cx - x[i])) / (x[i2] - x[i]);
cntx[cx] += cy;
tot += cy;
}
}
void removeBottom(int i, int i2, bool skipStart) {
for (long long cx = x[i] + skipStart; cx <= x[i2]; cx++) {
long long cy = (y[i] * (x[i2] - cx) + y[i2] * (cx - x[i])) / (x[i2] - x[i]);
if (cy * (x[i2] - x[i]) == (y[i] * (x[i2] - cx) + y[i2] * (cx - x[i])))
cy--;
cntx[cx] -= cy;
tot -= cy;
}
}
void run() {
for (int i = 0; i <= 2000005; i++) cntx[i] = 0;
tot = 0;
int j = 0;
while (1) {
if (x[(j + 1) % N] < x[j])
j = (j + 1) % N;
else if (x[(j + N - 1) % N] < x[j])
j = (j + N - 1) % N;
else
break;
}
if (y[(j + 1) % N] > y[(j + N - 1) % N]) {
bool skip = 0;
for (int i = j; x[(i + 1) % N] >= x[i]; i = (i + 1) % N)
if (x[(i + 1) % N] > x[i]) {
addTop(i, (i + 1) % N, skip);
skip = 1;
}
skip = 0;
for (int i = j; x[(i + N - 1) % N] >= x[i]; i = (i + N - 1) % N)
if (x[(i + N - 1) % N] > x[i]) {
removeBottom(i, (i + N - 1) % N, skip);
skip = 1;
}
} else {
bool skip = 0;
for (int i = j; x[(i + 1) % N] >= x[i]; i = (i + 1) % N)
if (x[(i + 1) % N] > x[i]) {
removeBottom(i, (i + 1) % N, skip);
skip = 1;
}
skip = 0;
for (int i = j; x[(i + N - 1) % N] >= x[i]; i = (i + N - 1) % N)
if (x[(i + N - 1) % N] > x[i]) {
addTop(i, (i + N - 1) % N, skip);
skip = 1;
}
}
for (int i = 1; i <= 2000005; i++) {
sm0[i] = sm0[i - 1] + cntx[i];
double csm0 = sm0[i - 1] + cntx[i] / 2.0;
csm0 /= tot;
csm0 /= (tot - 1);
sm1[i] = sm1[i - 1] + csm0;
sm2[i] = sm2[i - 1] + sm1[i];
ans += cntx[i] * sm2[i - 1];
}
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> x[i] >> y[i];
x[i] += 1000001, y[i] += 1000001;
}
run();
for (int i = 0; i < N; i++) swap(x[i], y[i]);
run();
cout << setprecision(20) << 2.0 * ans << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
pair<int, int> A[1000005];
int N;
void Init() {
Get(N);
for (int i = 1; i <= N; i++) {
Get(A[i].first);
Get(A[i].second);
A[i].first += 1000005;
A[i].second += 1000005;
}
}
double Floor(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) *
(A[Y].second - A[X].second) /
(double)(A[Y].first - A[X].first);
return floor(Y1 + (1e-8));
}
double Ceil(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) *
(A[Y].second - A[X].second) /
(double)(A[Y].first - A[X].first);
return ceil(Y1 - (1e-8));
}
long long F[10000005];
double Ans;
void Calc() {
rotate(A + 1, min_element(A + 1, A + N + 1), A + N + 1);
A[N + 1] = A[1];
int Pos = max_element(A + 1, A + N + 1) - A;
int P = A[1].first, Q = A[Pos].first;
for (int i = P, k = 1; i <= Q; i++) {
for (; A[k + 1].first < i;) k++;
int Pos = Ceil(k, k + 1, i);
F[i] = -Pos + 1;
}
long long Cnt = 0;
long long SumX = 0;
for (int i = Q, k = Pos; i >= P; i--) {
for (; A[k + 1].first > i;) k++;
int Pos = Floor(k, k + 1, i);
F[i] += Pos;
Cnt += F[i];
SumX += (i - 1000005) * F[i];
}
for (int i = Q; i >= P; i--)
Ans += F[i] * (i - 1000005) * (i - 1000005) / ((double)Cnt - 1);
Ans -= (double)SumX * SumX / ((double)(Cnt - 1) * Cnt);
}
void Work() {
long long S = 0;
A[N + 1] = A[1];
for (int k = 1; k <= N + 1; k++)
S += A[k].first * A[k + 1].second - A[k].second * A[k + 1].first;
if (S < 0) reverse(A + 1, A + N + 1);
Calc();
for (int k = 1; k <= N; k++) std::swap(A[k].first, A[k].second);
reverse(A + 1, A + N + 1);
Calc();
}
void Output() { printf("%.15lf\n", (double)Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100000 + 10;
int n;
struct point {
int first, second;
point(int a, int b) : first(a), second(b) {}
point() {}
} d[MAX];
long long chaji(const point& s, const point& a, const point& b) {
return (long long)(a.first - s.first) * (b.second - s.second) -
(long long)(a.second - s.second) * (b.first - s.first);
}
const int INF = 100000000;
const int MAXL = 2000000 + 10;
const int DELTA = 1000000;
int up[MAXL], down[MAXL];
long double get(point a, point b, long double s) {
long double r = (s - a.first) / (b.first - a.first);
return r * (b.second - a.second) + a.second;
}
long double calc() {
int i;
long double S = 0;
for ((i) = (0); (i) != (n); ++(i))
S += chaji(point(0, 0), d[i], d[(i + 1) % n]);
if (S < 0) reverse(d, d + n);
for ((i) = (-DELTA); (i) <= (DELTA); ++(i)) {
up[i + DELTA] = -INF;
down[i + DELTA] = INF;
}
for ((i) = (0); (i) != (n); ++(i)) {
int j = (i + 1) % n;
int k;
if (d[i].first < d[j].first)
for ((k) = (d[i].first); (k) <= (d[j].first); ++(k)) {
int second = ceil(get(d[i], d[j], k));
while (chaji(d[i], d[j], point(k, second - 1)) >= 0) --second;
down[k + DELTA] = second;
}
else if (d[i].first > d[j].first)
for (k = d[i].first; k >= d[j].first; --k) {
int second = floor(get(d[i], d[j], k));
while (chaji(d[i], d[j], point(k, second + 1)) >= 0) ++second;
up[k + DELTA] = second;
}
else {
int l = d[i].second, r = d[j].second;
if (l > r) swap(l, r);
up[d[i].first + DELTA] = max(r, up[d[i].first + DELTA]);
down[d[i].first + DELTA] = min(l, down[d[i].first + DELTA]);
}
}
long double tot = 0, tot2 = 0, all = 0;
for ((i) = (-DELTA); (i) <= (DELTA); ++(i))
if (up[i + DELTA] >= down[i + DELTA]) {
long double num = up[i + DELTA] - down[i + DELTA] + 1;
tot += num * i;
tot2 += num * i * i;
all += num;
}
long double ans = 0;
long double div = all * (all - 1);
for ((i) = (-DELTA); (i) <= (DELTA); ++(i))
if (up[i + DELTA] >= down[i + DELTA]) {
long double num = up[i + DELTA] - down[i + DELTA] + 1;
ans += num * i * i / div * all;
ans -= num * 2 * i / div * tot;
ans += num / div * tot2;
}
return ans;
}
int main() {
int i;
scanf("%d", &n);
for ((i) = (0); (i) != (n); ++(i)) scanf("%d%d", &d[i].first, &d[i].second);
long double ans = 0;
ans = calc();
for ((i) = (0); (i) != (n); ++(i)) swap(d[i].first, d[i].second);
ans += calc();
printf("%.15lf", (double)ans / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
double calc(vector<int> &v) {
int n = (int((v).size()));
long double ret = 0.0;
long double a = 0;
long double b = 0;
long double c = 0;
c = v[0];
for (int i = (int)(1), _n = (int)(n); i < _n; i++) {
b += 2 * c - v[i - 1];
a += b;
ret += v[i] * (long double)a;
c += v[i];
}
return 2 * ret / (c * (long double)(c - 1));
}
double solve(vector<pair<int, int> > p) {
rotate(p.begin(), min_element((p).begin(), (p).end()), p.end());
p.push_back(p[0]);
int maxind = max_element((p).begin(), (p).end()) - p.begin(), cur = 0;
int minx = p[0].first, maxx = p[maxind].first;
vector<int> v(maxx - minx + 1);
for (int x = minx, i = 0; x <= maxx; x++, i++) {
if (p[cur + 1].first > p[cur].first && x == p[cur + 1].first) cur++;
if (x == p[cur].first)
v[i] = -p[cur].second;
else {
int ydiff = (p[cur + 1].second - p[cur].second) *
(long long)(x - p[cur].first) /
(p[cur + 1].first - p[cur].first);
if ((p[cur + 1].first - p[cur].first) * (long long)ydiff <
(p[cur + 1].second - p[cur].second) * (long long)(x - p[cur].first))
ydiff++;
v[i] = -(p[cur].second + ydiff);
}
}
cur = maxind;
for (int x = maxx, i = maxx - minx; x >= minx; x--, i--) {
if (p[cur + 1].first < p[cur].first && x == p[cur + 1].first) cur++;
if (x == p[cur].first)
v[i] += p[cur].second + 1;
else {
int ydiff = (p[cur + 1].second - p[cur].second) *
(long long)(p[cur].first - x) /
(p[cur].first - p[cur + 1].first);
if ((p[cur].first - p[cur + 1].first) * (long long)ydiff >
(p[cur + 1].second - p[cur].second) * (long long)(p[cur].first - x))
ydiff--;
v[i] += p[cur].second + ydiff + 1;
}
}
return calc(v);
}
inline long long cross(pair<int, int> p, pair<int, int> q1, pair<int, int> q2) {
return (q1.first - p.first) * (long long)(q2.second - p.second) -
(q1.second - p.second) * (long long)(q2.first - p.first);
}
int main() {
ios::sync_with_stdio(false);
int n;
bool cc = false;
cin >> n;
vector<pair<int, int> > p(n);
for (int i = 0, _n = (int)(n); i < _n; i++) {
cin >> p[i].first >> p[i].second;
if (i >= 2)
if (cross(p[i - 2], p[i - 1], p[i]) < 0) cc = true;
}
if (cc) reverse((p).begin(), (p).end());
double ans1 = solve(p);
for (int i = 0, _n = (int)(n); i < _n; i++) swap(p[i].first, p[i].second);
reverse((p).begin(), (p).end());
double ans2 = solve(p);
cout << fixed << setprecision(9) << (ans1 + ans2) / 2 << endl;
{
int _;
cin >> _;
return 0;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
void scan() { scanf("%d%d", &x, &y); }
} x[110000];
int n, L, R, U, D;
long double num[2100000];
long double *A;
long double get(point k1, point k2, int k3) {
if (k1.x == k2.x) return k2.y;
return (long double)(k3 - k1.x) / (long double)(k2.x - k1.x) * (k2.y - k1.y) +
k1.y;
}
int pre(int k) { return (k - 2 + n) % n + 1; }
int next(int k) { return k % n + 1; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) x[i].scan();
A = num + 1005000;
L = 1e7;
R = -1e7;
for (int i = 1; i <= n; i++) {
L = min(L, x[i].x);
R = max(R, x[i].x);
}
int l, r;
for (int i = 1; i <= n; i++)
if (x[i].x == L) {
l = i;
r = i;
break;
}
for (int i = L; i <= R; i++) {
while (x[l].x <= i && x[l].x != R) l = pre(l);
while (x[r].x <= i && x[r].x != R) r = next(r);
long double k3 = get(x[l], x[next(l)], i), k4 = get(x[r], x[pre(r)], i);
if (k3 > k4) swap(k3, k4);
int k1 = floor(k3 - 1e-7) + 1, k2 = floor(k4 + 1e-7);
A[i] = k2 - k1 + 1;
}
long double ans = 0, tot = 0, sum = 0;
for (int i = L; i <= R; i++) {
tot += A[i];
sum += A[i] * i;
}
for (int i = L; i <= R; i++) {
ans += -sum * 2 * A[i] * i + A[i] * (A[i] + 1) * (long double)i * i +
(long double)i * i * A[i] * (tot - 1);
sum -= A[i] * i;
}
memset(num, 0x00, sizeof num);
for (int i = 1; i <= n; i++) swap(x[i].x, x[i].y);
L = 1e7;
R = -1e7;
for (int i = 1; i <= n; i++) {
L = min(L, x[i].x);
R = max(R, x[i].x);
}
for (int i = 1; i <= n; i++)
if (x[i].x == L) {
l = i;
r = i;
break;
}
for (int i = L; i <= R; i++) {
while (x[l].x <= i && x[l].x != R) l = pre(l);
while (x[r].x <= i && x[r].x != R) r = next(r);
long double k3 = get(x[l], x[next(l)], i), k4 = get(x[r], x[pre(r)], i);
if (k3 > k4) swap(k3, k4);
int k1 = floor(k3 - 1e-7) + 1, k2 = floor(k4 + 1e-7);
A[i] = k2 - k1 + 1;
}
tot = 0, sum = 0;
for (int i = L; i <= R; i++) {
tot += A[i];
sum += A[i] * i;
}
for (int i = L; i <= R; i++) {
ans += -sum * 2 * A[i] * i + A[i] * (A[i] + 1) * (long double)i * i +
(long double)i * i * A[i] * (tot - 1);
sum -= A[i] * i;
}
printf("%.11lf\n", (double)(ans / tot / (tot - 1)));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1E-8;
struct node {
long double x, s, t;
} a[2000010];
int xi[2000010], yi[2000010];
long double li[2000010], ri[2000010], ans, s, t;
int n, m;
void work(int x0, int y0, int x1, int y1) {
if (x0 > x1) swap(x0, x1), swap(y0, y1);
if (x0 == x1) {
li[x0] = min(li[x0], (long double)min(y0, y1)),
ri[x0] = max(ri[x0], (long double)max(y0, y1));
return;
}
for (int i = x0; i <= x1; i++) {
long double k = 1. * (y1 - y0) * (i - x0) / (x1 - x0) + y0;
li[i] = min(li[i], k), ri[i] = max(ri[i], k);
}
}
void solve(void) {
for (int i = 0; i < 2000010; i++) ri[i] = 0, li[i] = 2000010;
for (int i = 1; i <= n; i++) work(xi[i], yi[i], xi[i + 1], yi[i + 1]);
m = 0;
for (int i = 0; i < 2000010; i++)
if (li[i] < 2000010) {
int A = int(li[i] - eps) + 1, B = int(ri[i] + eps);
m++, a[m].x = i, a[m].s = B - A + 1;
a[m].t = a[m].x * a[m].s;
}
s = t = 0;
for (int i = 1; i <= m; i++) s += a[i].s, t += a[i].t;
for (int i = 1; i <= m; i++)
ans += a[i].t * a[i].x * (s - a[i].s) - (a[i].t * (t - a[i].t));
}
int main(void) {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", xi + i, yi + i), xi[i] += 2000010 >> 1, yi[i] += 2000010 >> 1;
xi[n + 1] = xi[1], yi[n + 1] = yi[1], solve();
for (int i = 1; i <= n + 1; i++) swap(xi[i], yi[i]);
solve();
ans /= s * (s - 1), printf("%.10lf\n", (double)ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxXL = 1000000;
const int MaxN = 100000;
inline long long floor(long long a, long long b) {
if (b < 0) a = -a, b = -b;
if (a > 0) return a / b;
return -((-a + b - 1) / b);
}
inline long long ceil(long long a, long long b) { return -floor(-a, b); }
double calc(int n, int *px, int *py) {
long long area = 0;
for (int i = 0; i < n; i++)
area += (long long)px[i] * py[i + 1] - (long long)py[i] * px[i + 1];
if (area < 0) reverse(px + 1, px + n), reverse(py + 1, py + n);
static int h[MaxXL * 2 + 1];
fill(h, h + MaxXL * 2 + 1, 0);
for (int i = 0; i < n; i++) {
if (px[i] < px[i + 1]) {
for (int x = px[i]; x < px[i + 1]; x++)
h[x + MaxXL] -= py[i] +
ceil((long long)(py[i + 1] - py[i]) * (x - px[i]),
px[i + 1] - px[i]) -
1;
if (px[i + 1] >= px[(i + 2) % n]) h[px[i + 1] + MaxXL] -= py[i + 1] - 1;
} else if (px[i] > px[i + 1]) {
for (int x = px[i]; x > px[i + 1]; x--)
h[x + MaxXL] +=
py[i] + floor((long long)(py[i + 1] - py[i]) * (x - px[i]),
px[i + 1] - px[i]);
if (px[i + 1] <= px[(i + 2) % n]) h[px[i + 1] + MaxXL] += py[i + 1];
}
}
long long cnt = 0;
double sum1 = 0;
double sum2 = 0;
for (int x = -MaxXL; x <= MaxXL; x++) {
cnt += h[x + MaxXL];
sum1 += (double)x * h[x + MaxXL];
sum2 += (double)x * x * h[x + MaxXL];
}
sum1 /= cnt;
sum2 /= cnt;
return (sum2 - sum1 * sum1) * cnt / (cnt - 1);
}
int main() {
int n;
static int px[MaxN + 1], py[MaxN + 1];
cin >> n;
for (int i = 0; i < n; i++) scanf("%d %d", &px[i], &py[i]);
px[n] = px[0], py[n] = py[0];
double res = 0;
res += calc(n, px, py);
res += calc(n, py, px);
printf("%.8f\n", res);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
pair<int, int> A[1000005];
int N;
void Init() {
Get(N);
for (int i = 1; i <= N; i++) {
Get(A[i].first);
Get(A[i].second);
A[i].first += 1000005;
A[i].second += 1000005;
}
}
double Floor(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) *
(A[Y].second - A[X].second) /
(double)(A[Y].first - A[X].first);
return floor(Y1 + (1e-8));
}
double Ceil(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) *
(A[Y].second - A[X].second) /
(double)(A[Y].first - A[X].first);
return ceil(Y1 - (1e-8));
}
long double F[10000005];
long double Ans;
void Calc() {
rotate(A + 1, min_element(A + 1, A + N + 1), A + N + 1);
A[N + 1] = A[1];
int Pos = max_element(A + 1, A + N + 1) - A;
int P = A[1].first, Q = A[Pos].first;
for (int i = P, k = 1; i <= Q; i++) {
if (A[k + 1].first < i) k++;
int Pos = Ceil(k, k + 1, i);
F[i] = -Pos + 1;
}
long double Cnt = 0;
long double SumX = 0;
for (int i = Q, k = Pos; i >= P; i--) {
if (A[k + 1].first > i) k++;
int Pos = Floor(k, k + 1, i);
F[i] += Pos;
Cnt += F[i];
SumX += (i - 1000005) * F[i];
}
for (int i = Q; i >= P; i--)
Ans += F[i] * (i - 1000005) * (i - 1000005) / (Cnt - 1);
Ans -= SumX * SumX / ((Cnt - 1) * Cnt);
}
void Work() {
long long S = 0;
A[N + 1] = A[1];
for (int k = 1; k <= N + 1; k++)
S += A[k].first * A[k + 1].second - A[k].second * A[k + 1].first;
if (S < 0) reverse(A + 1, A + N + 1);
Calc();
for (int k = 1; k <= N; k++) swap(A[k].first, A[k].second);
reverse(A + 1, A + N + 1);
Calc();
}
void Output() { printf("%.15lf\n", (double)Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
const double eps = 1e-6;
struct _two {
int a, b;
} a[N];
int n;
int num[N];
double Min[N], Max[N], sum[N], sum1[N];
double ans, s;
void Work(_two x, _two y) {
if (x.a > y.a) swap(x, y);
if (x.a == y.a) return;
double t = (y.b - x.b) / (0. + y.a - x.a), cur = x.b;
for (int i = x.a; i <= y.a; i++) {
Min[i] = min(Min[i], cur);
Max[i] = max(Max[i], cur);
cur += t;
}
}
void Calc() {
a[0] = a[n];
for (int i = 0; i <= N - 1; i++) Min[i] = N, Max[i] = 0;
for (int i = 1; i <= n; i++) Work(a[i - 1], a[i]);
memset(num, 0, sizeof(num));
s = 0;
for (int i = 0; i <= N - 1; i++)
if (Min[i] < Max[i] + eps) {
int L = (int)(Min[i] - eps) + 1, R = (int)(Max[i] + eps);
s += num[i] = R - L + 1;
}
sum[0] = sum1[0] = 0;
for (int i = 1; i <= N - 1; i++) sum[i] = sum[i - 1] + num[i];
for (int i = 1; i <= N - 1; i++) sum1[i] = sum1[i - 1] + sum[i] + sum[i - 1];
double cur = 0;
for (int i = 1; i <= N - 1; i++) {
ans += num[i] * cur;
cur += sum1[i];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].a, &a[i].b);
a[i].a += N / 2;
a[i].b += N / 2;
}
Calc();
for (int i = 1; i <= n; i++) swap(a[i].a, a[i].b);
Calc();
printf("%.7lf\n", ans / (s * (s - 1)));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, up[3000005], low[3000005], cnt[3000005];
double ans;
struct point {
int x, y;
} P[101000];
double tot;
double solve() {
double area = 0;
tot = 0;
for (int i = 0; i < n; i++)
area += P[i].x * P[(i + 1) % n].y - P[i].y * P[(i + 1) % n].x;
if (area < 0) reverse(P, P + n);
P[n] = P[0];
int mx = 0;
for (int i = 0; i < n; i++) mx = max(P[i].x, mx);
for (int i = 0; i < n; i++) {
long long x1 = P[i].x, x2 = P[i + 1].x, y1 = P[i].y, y2 = P[i + 1].y;
if (x1 < x2) {
for (int j = x1; j <= x2; j++)
low[j] =
(y1 * (x2 - x1) + ((y2 - y1) * (j - x1) + x2 - x1 - 1)) / (x2 - x1);
} else if (P[i].x > P[i + 1].x) {
for (int j = P[i + 1].x; j <= P[i].x; j++)
up[j] = (y2 * (x1 - x2) + (y1 - y2) * (j - x2)) / (x1 - x2);
}
}
for (int i = 0; i <= mx; i++) {
cnt[i] = up[i] - low[i] + 1;
tot += cnt[i];
}
double ans1 = 0, ans2 = 0;
for (int i = 0; i <= mx; i++) {
ans1 += (double)cnt[i] * i * i;
ans2 += (double)cnt[i] * i;
}
return (ans1 * tot - ans2 * ans2);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &P[i].x, &P[i].y);
int id = P[0].x;
for (int i = 0; i < n; i++)
if (P[i].x < id) id = P[i].x;
for (int i = 0; i < n; i++) P[i].x -= id;
id = P[0].y;
for (int i = 0; i < n; i++)
if (P[i].y < id) id = P[i].y;
for (int i = 0; i < n; i++) P[i].y -= id;
ans += solve();
for (int i = 0; i <= n; i++) swap(P[i].x, P[i].y);
ans += solve();
printf("%.10f\n", ans / tot / (tot - 1));
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dcmp(long double p) {
if (abs(p) < 1e-13) return 0;
return p > 1e-13 ? 1 : -1;
}
vector<long double> L[2000010];
int n;
void read() {
scanf("%d", &n);
static long long x[100010], y[100010];
for (int i = 1; i <= n; ++i) {
cin >> x[i] >> y[i];
x[i] += 1000001, y[i] += 1000001;
}
for (int i = 1; i <= n; ++i) {
if (x[i] == x[i % n + 1])
L[x[i]].push_back(y[i]), L[x[i]].push_back(y[i % n + 1]);
else {
long double k = 1.0 * (y[i % n + 1] - y[i]) / (x[i % n + 1] - x[i]),
b = y[i] - x[i] * k;
for (int j = min(x[i], x[i % n + 1]); j <= max(x[i], x[i % n + 1]); ++j) {
long double vy = k * j + b;
if (dcmp(k) >= 0)
L[j].push_back(vy);
else
L[j].push_back(vy);
}
}
}
}
long long sum2(int n) {
long long a = n, b = n + 1, c = 2 * n + 1;
if (a % 2 == 0)
a /= 2;
else
b /= 2;
if (a % 3 == 0)
a /= 3;
else if (b % 3 == 0)
b /= 3;
else
c /= 3;
return a * b * c;
}
long double work() {
long long total = 0;
for (int i = 1; i <= 2000005; ++i)
if (L[i].size() > 1u) {
sort(L[i].begin(), L[i].end());
L[i].resize(unique(L[i].begin(), L[i].end()) - L[i].begin());
if (L[i].size() > 1u) {
long long l = ceil(L[i][0] - 1e-13),
r = floor(L[i][L[i].size() - 1u] + 1e-13);
total += r - l + 1;
} else if (L[i].size())
++total;
}
long double sumx1 = 0, sumy1 = 0, sumx2 = 0, sumy2 = 0, v = 1.0 / total;
for (int i = 1; i <= 2000005; ++i) {
if (L[i].size() > 1u) {
long long l = ceil(L[i][0] - 1e-13),
r = floor(L[i][L[i].size() - 1u] + 1e-13);
sumx1 += v * (r - l + 1) * i, sumx2 += v * (r - l + 1) * i * i;
sumy1 += v * (l + r) * (r - l + 1) / 2,
sumy2 += v * (sum2(r) - sum2(l - 1));
} else if (L[i].size() == 1u) {
long long y = floor(L[i][0] + 1e-13);
sumx1 += v * i, sumx2 += v * i * i;
sumy1 += v * y, sumy2 += v * y * y;
}
}
return (sumx2 + sumy2 - sumx1 * sumx1 - sumy1 * sumy1) / v / (total - 1);
}
int main() {
read();
printf("%.10f\n", (double)work());
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct pt {
int x, y;
pt(int xx = 0, int yy = 0) : x(xx), y(yy) {}
};
pt operator-(pt a, pt b) { return pt(a.x - b.x, a.y - b.y); }
bool operator<(const pt &a, const pt &b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
long long cross(pt a, pt b) { return (a.x + 0ll) * b.y - (a.y + 0ll) * b.x; }
int sta[maxn << 1], top;
pt p[maxn];
void convex(int n) {
top = 0;
sort(p + 1, p + 1 + n);
int i, j;
for (i = 1; i <= n; i++) {
while (top >= 2 &&
cross(p[i] - p[sta[top]], p[sta[top]] - p[sta[top - 1]]) >= 0)
top--;
sta[++top] = i;
}
j = top;
for (i = n - 1; i >= 1; i--) {
while (top > j &&
cross(p[i] - p[sta[top]], p[sta[top]] - p[sta[top - 1]]) >= 0)
top--;
sta[++top] = i;
}
top--;
}
double ans = 0;
int shang[2000010], xia[2000010];
double solve(int n) {
convex(n);
int s, x, i, j;
int mi = 210000000, ma = 0;
for (i = 1; i <= top; i++) {
if (p[sta[i]].x == p[sta[i + 1]].x) {
s = max(p[sta[i]].y, p[sta[i + 1]].y);
x = min(p[sta[i]].y, p[sta[i + 1]].y);
shang[p[sta[i]].x] = s;
xia[p[sta[i]].x] = x;
} else if (p[sta[i]].x < p[sta[i + 1]].x) {
j = p[sta[i]].x;
x = p[sta[i]].y;
do {
xia[j] = x;
j++;
while (cross(pt(j, x) - p[sta[i]], p[sta[i + 1]] - p[sta[i]]) > 0) x++;
while (cross(pt(j, x - 1) - p[sta[i]], p[sta[i + 1]] - p[sta[i]]) <= 0)
x--;
} while (j <= p[sta[i + 1]].x);
} else {
j = p[sta[i]].x;
x = p[sta[i]].y;
do {
shang[j] = x;
j--;
while (cross(pt(j, x) - p[sta[i]], p[sta[i + 1]] - p[sta[i]]) > 0) x--;
while (cross(pt(j, x + 1) - p[sta[i]], p[sta[i + 1]] - p[sta[i]]) <= 0)
x++;
} while (j >= p[sta[i + 1]].x);
}
mi = min(mi, p[sta[i]].x);
ma = max(ma, p[sta[i]].x);
}
long long tot = 0, ss = 0, tmp;
for (i = mi; i <= ma; i++)
tot += shang[i] - xia[i] + 1, ss += (shang[i] - xia[i] + 1ll) * i;
for (i = mi; i <= ma; i++) {
ans += (shang[i] - xia[i] + 1ll) * i / (tot - 1.0) *
((tot * i - ss) / (tot + 0.0));
}
return ans;
}
int main() {
int n;
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d%d", &p[i].x, &p[i].y), p[i].x += 1000000, p[i].y += 1000000;
solve(n);
for (i = 1; i <= n; i++) swap(p[i].x, p[i].y);
solve(n);
printf("%.12lf\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, s[100005][2], fn[2000005];
double ans, ptot, f[2000005][3];
void makeline(double x0, double y0, double x1, double y1, double *a, double *b,
double *c) {
*a = y1 - y0;
*b = x0 - x1;
*c = x1 * y0 - y1 * x0;
return;
}
double intersection(double a, double b, double c, double x) {
if (a == 0)
return -c / b;
else
return (-c - a * x) / b;
}
void calc(void) {
int i, j, l, r, left = LONG_MAX, right = -LONG_MAX, dx;
double a0, b0, c0, del2, co1, co2;
ptot = 0;
memset(f, 0, sizeof(f));
memset(fn, 0, sizeof(fn));
for (i = 0; i < n; i++) {
makeline(s[i][0], s[i][1], s[i + 1][0], s[i + 1][1], &a0, &b0, &c0);
l = s[i][0];
r = s[i + 1][0];
if (l <= r)
dx = 1;
else
dx = -1;
if (b0 == 0) {
f[s[i][0]][++fn[s[i][0]]] = s[i][1];
continue;
}
left = min(left, min(s[i][0], s[i + 1][0]));
right = max(right, max(s[i][0], s[i + 1][0]));
for (j = l; j != r; j += dx) f[j][++fn[j]] = intersection(a0, b0, c0, j);
}
for (i = left, del2 = co1 = co2 = 0; i <= right; i++) {
if (f[i][1] > f[i][2]) swap(f[i][1], f[i][2]);
if (fn[i] == 1)
f[i][0] = 1;
else
f[i][0] = floor(f[i][2] + 1e-6) - ceil(f[i][1] - 1e-6) + 1;
ptot += f[i][0];
co2 += co1;
ans += f[i][0] * co2;
co1 += del2 + f[i][0];
del2 += f[i][0] * 2;
}
return;
}
int main() {
int i;
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d%d", &s[i][0], &s[i][1]), s[i][0] += 1000000, s[i][1] += 1000000;
s[n][0] = s[0][0];
s[n][1] = s[0][1];
ans = 0;
calc();
for (i = 0; i <= n; i++) swap(s[i][0], s[i][1]);
calc();
ans /= ptot * (ptot - 1);
printf("%.8lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int OFFSET = 1000100;
const double oo = 1e18;
const double EPS = 1e-8;
int n, x[100100], y[100100];
double yLow[2000200], yHigh[2000200];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
scanf("%d%d", x + i, y + i), x[i] += OFFSET, y[i] += OFFSET;
x[n] = x[0];
y[n] = y[0];
int xLow = x[0], xHigh = x[0];
for (int i = 1; i < n; i++) {
xLow = min(xLow, x[i]);
xHigh = max(xHigh, x[i]);
}
for (int i = xLow; i <= xHigh; i++) yLow[i] = oo, yHigh[i] = -oo;
for (int i = 0; i < n; i++)
if (x[i] == x[i + 1]) {
yLow[x[i]] = min(yLow[x[i]], 1.0 * min(y[i], y[i + 1]));
yHigh[x[i]] = min(yHigh[x[i]], 1.0 * max(y[i], y[i + 1]));
} else {
double A = y[i] - y[i + 1], B = x[i + 1] - x[i], C = -A * x[i] - B * y[i];
int xL = min(x[i], x[i + 1]), xR = max(x[i], x[i + 1]);
for (int curX = xL; curX <= xR; curX++) {
double curY = (-C - A * curX) / B;
yLow[curX] = min(yLow[curX], curY);
yHigh[curX] = max(yHigh[curX], curY);
}
}
double sumX = 0, sumY = 0, sumXSqr = 0, sumYSqr = 0, point = 0;
for (int curX = xLow; curX <= xHigh; curX++) {
int ylow = int(yLow[curX] + 1 - EPS), yhigh = int(yHigh[curX] + EPS);
point += yhigh - ylow + 1;
sumX += (yhigh - ylow + 1.0) * curX;
sumXSqr += (yhigh - ylow + 1.0) * curX * curX;
sumY += (yhigh + ylow) * (yhigh - ylow + 1.0) / 2;
sumYSqr += yhigh * (yhigh + 1.0) * (yhigh * 2 + 1) / 6 -
(ylow - 1.0) * (ylow) * (ylow * 2 - 1) / 6;
}
double ans = (sumXSqr + sumYSqr) - (sumX * sumX + sumY * sumY) / point;
ans /= (point - 1);
printf("%.12lf\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long fpm(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
T gcd(T x, T y) {
for (T t; x; t = x, x = y % x, y = t)
;
return y;
}
template <class edge>
struct Graph {
vector<vector<edge> > adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
Graph() { adj.clear(); }
void resize(int n) { adj.resize(n + 5); }
void add(int s, edge e) { adj[s].push_back(e); }
void del(int s, edge e) { adj[s].erase(find(iter(adj[s]), e)); }
vector<edge> &operator[](int t) { return adj[t]; }
};
const int U = 1100000, maxn = U;
const long double eps = 1e-10;
int n;
long double tot;
set<long double> S[U * 2 + 10];
int x[maxn], y[maxn];
int w[maxn];
long double work() {
long double ret = 0;
for (int _end_ = (U + U), i = (0); i <= _end_; ++i) S[i].clear();
for (int _end_ = (n), i = (1); i <= _end_; ++i) {
int l = i, r = i % n + 1;
if (x[l] > x[r]) swap(l, r);
if (x[l] == x[r]) {
S[x[l] + U].insert(y[l]);
S[x[r] + U].insert(y[r]);
continue;
}
for (int _end_ = (x[r]), a = (x[l]); a <= _end_; ++a) {
S[a + U].insert(
(long double)(1ll * y[l] * (x[r] - a) + 1ll * y[r] * (a - x[l])) /
(x[r] - x[l]));
}
}
long double S0 = 0, S1 = 0, S2 = 0;
for (int _end_ = (U), i = (-U); i <= _end_; ++i) {
if (!(int)((S[i + U]).size())) continue;
long double l = *S[i + U].begin(), r = *--S[i + U].end();
int lb = ceil(l - eps);
int rb = floor(r + eps);
long double v = rb - lb + 1;
ret += v * (S2 - 2 * S1 * i + S0 * i * i);
S2 += 1.0 * v * i * i;
S1 += 1.0 * v * i;
S0 += 1.0 * v;
}
cerr << "ret: " << ret << " " << S0 << endl;
if (tot) assert(tot == S0);
tot = S0;
for (int _end_ = (n), i = (1); i <= _end_; ++i) swap(x[i], y[i]);
return ret;
}
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
cin >> n;
for (int _end_ = (n), i = (1); i <= _end_; ++i) {
cin >> x[i] >> y[i];
}
cout << setprecision(15) << (work() + work()) / tot / (tot - 1) << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int MAXN = 100005;
const int SZ = 2000005;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-10;
struct Point {
int x, y;
};
long long cross(const Point &x, const Point &y) {
return (long long)x.x * y.y - (long long)x.y * y.x;
}
int n;
Point a[MAXN];
int left[SZ];
int right[SZ];
int cc[SZ];
void init() {
const int SZ2 = 1000002;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i].x += SZ2;
a[i].y += SZ2;
}
long long sum = 0;
for (int i = 0; i < n; ++i) sum += cross(a[i], a[(i + 1) % n]);
if (sum < 0) std::reverse(a + 1, a + n);
}
void work(long long &cnt, double &sum) {
memset(left, INF, sizeof(left));
memset(right, -INF, sizeof(right));
for (int i = 0; i < n; ++i) {
int x1 = a[i].x;
int x2 = a[(i + 1) % n].x;
int y1 = a[i].y;
int y2 = a[(i + 1) % n].y;
int minx = std::min(x1, x2);
int maxx = std::max(x1, x2);
for (int j = minx; j <= maxx; ++j) {
double y = (double)(j - x1) / (x2 - x1) * (y2 - y1) + y1;
if (x1 < x2) left[j] = (int)(y + 1 - EPS);
if (x1 > x2) right[j] = (int)(y + EPS);
}
}
cnt = 0;
for (int i = 0; i < SZ; ++i)
if (left[i] <= right[i])
cnt += cc[i] = right[i] - left[i] + 1;
else
cc[i] = 0;
double p1 = 0;
double p2 = 0;
double p3 = 0;
sum = 0;
for (int i = 0; i < SZ; ++i) {
sum += cc[i] * p1;
p3 += cc[i];
p2 += 2 * p3 - cc[i];
p1 += p2;
}
}
void solve() {
long long cnt;
double sumx, sumy;
work(cnt, sumy);
for (int i = 0; i < n; ++i) std::swap(a[i].x, a[i].y);
std::reverse(a + 1, a + n);
work(cnt, sumx);
printf("%.12f\n", (sumx + sumy) / 2 / ((double)cnt * (cnt - 1) / 2));
}
int main() {
init();
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
} high, low, st, en, temp_up, temp_down;
long long n, k;
long long total = 0, cntx[2000002], cnty[2000002];
vector<point> v, up, down;
long long check(point a, point b, point c) {
return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1, x, y; i <= n; i++) {
cin >> x >> y;
v.push_back({x + 1000000, y + 1000000});
}
sort(v.begin(), v.end(),
[](point a, point b) { return a.x < b.x || (a.x == b.x && a.y < b.y); });
st = v[0], en = v.back();
for (long long i = 0; i < (long long)v.size(); i++) {
if (i != (long long)v.size() - 1 && check(v[i], st, en) < 0) continue;
while (up.size() > 2 &&
check(up[up.size() - 1], up[up.size() - 2], v[i]) < 0) {
up.pop_back();
}
up.push_back(v[i]);
}
for (long long i = 0; i < (long long)v.size(); i++) {
if (i != (long long)v.size() - 1 && check(v[i], st, en) > 0) continue;
while (down.size() > 2 &&
check(down[down.size() - 1], down[down.size() - 2], v[i]) > 0) {
down.pop_back();
}
down.push_back(v[i]);
}
high = low = {v[0].x + 1, v[0].y};
long long cur = 0, mn = v[0].y, mx = v[0].y;
while (1) {
cur++;
if (v[cur].x == v[cur - 1].x) {
mx = max(mx, v[cur].y);
mn = min(mn, v[cur].y);
} else {
break;
}
}
high.y = mx;
low.y = mn;
cntx[v[0].x] = high.y - low.y + 1;
while (high.x <= v.back().x && low.x <= v.back().x) {
long long k = lower_bound(up.begin(), up.end(), (point){high.x, 0},
[](point a, point b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}) -
up.begin();
temp_up = high;
while (check(up[k - 1], up[k], temp_up) <= 0) {
high = temp_up;
temp_up.y++;
}
while (check(up[k - 1], up[k], high) > 0) {
temp_up.y--;
high = temp_up;
}
k = lower_bound(down.begin(), down.end(), (point){low.x, 0},
[](point a, point b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}) -
down.begin();
temp_down = low;
while (check(down[k - 1], down[k], temp_down) >= 0) {
low = temp_down;
temp_down.y--;
}
while (check(down[k - 1], down[k], temp_down) < 0) {
temp_down.y++;
low = temp_down;
}
cntx[high.x] = high.y - low.y + 1;
high.x++;
low.x++;
}
up.clear();
down.clear();
sort(v.begin(), v.end(),
[](point a, point b) { return a.y < b.y || (a.y == b.y && a.x < b.x); });
st = v[0], en = v.back();
for (long long i = 0; i < (long long)v.size(); i++) {
if (i != (long long)v.size() - 1 && check(v[i], st, en) < 0) continue;
while (up.size() > 2 &&
check(up[up.size() - 1], up[up.size() - 2], v[i]) < 0) {
up.pop_back();
}
up.push_back(v[i]);
}
for (long long i = 0; i < (long long)v.size(); i++) {
if (i != (long long)v.size() - 1 && check(v[i], st, en) > 0) continue;
while (down.size() > 2 &&
check(down[down.size() - 1], down[down.size() - 2], v[i]) > 0) {
down.pop_back();
}
down.push_back(v[i]);
}
high = low = {v[0].x, v[0].y + 1};
cur = 0, mn = v[0].x, mx = v[0].x;
while (1) {
cur++;
if (v[cur].y == v[cur - 1].y) {
mx = max(mx, v[cur].x);
mn = min(mn, v[cur].x);
} else {
break;
}
}
low.x = mx;
high.x = mn;
cnty[v[0].y] = low.x - high.x + 1;
total += cnty[v[0].y];
while (high.y <= v.back().y && low.y <= v.back().y) {
k = lower_bound(up.begin(), up.end(), (point){0, high.y},
[](point a, point b) {
return a.y < b.y || (a.y == b.y && a.x < b.x);
}) -
up.begin();
point temp_up = high, temp_down = low;
while (check(up[k - 1], up[k], temp_up) <= 0) {
high = temp_up;
temp_up.x--;
}
while (check(up[k - 1], up[k], high) > 0) {
temp_up.x++;
high = temp_up;
}
k = lower_bound(down.begin(), down.end(), (point){0, low.y},
[](point a, point b) {
return a.y < b.y || (a.y == b.y && a.x < b.x);
}) -
down.begin();
while (check(down[k - 1], down[k], temp_down) >= 0) {
low = temp_down;
temp_down.x++;
}
while (check(down[k - 1], down[k], temp_down) < 0) {
temp_down.x--;
low = temp_down;
}
cnty[high.y] = low.x - high.x + 1;
total += cnty[high.y];
high.y++;
low.y++;
}
long long sumx = 0, sumy = 0;
double sumx_square = 0, sumy_square = 0;
long double ansx = 0, ansy = 0;
for (long long j = 0; j <= 2e6; j++) {
sumx += (j - 1e6) * cntx[j];
sumx_square +=
(long double)(j - 1e6) * (j - 1e6) / (total - 1) / 2 * cntx[j];
sumy += (j - 1e6) * cnty[j];
sumy_square +=
(long double)(j - 1e6) * (j - 1e6) / (total - 1) / 2 * cnty[j];
}
for (long long i = 0; i <= 2e6; i++) {
ansx += (long double)((i - 1e6) * total - 2ll * sumx) / total * (i - 1e6) /
(total - 1) * cntx[i] / 2;
ansy += (long double)((i - 1e6) * total - 2ll * sumy) / total * (i - 1e6) /
(total - 1) * cnty[i] / 2;
}
ansx += sumx_square;
ansy += sumy_square;
long double t = ansx + ansy;
cout << fixed << setprecision(10) << t << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int ding = 1000005;
const double eps = 1e-8;
long long n, m, z, x[100005], y[100005], a[2000011], l, r, mi, sum, node, t;
long long tx[100005], ty[100005];
long double ans, zc;
double fans;
inline int pre(int l) {
if (l > 1)
return l - 1;
else
return n;
}
inline int next(int l) {
if (l < n)
return l + 1;
else
return 1;
}
inline int workx(int p, int l, int r) {
int a, b;
if (x[l] == x[pre(l)])
a = min(y[l], y[pre(l)]) - 1;
else
a = ceil(y[l] + (y[pre(l)] - y[l]) / (1.0 * x[pre(l)] - x[l]) * (p - x[l]) -
eps) -
1;
if (x[r] == x[next(r)])
b = max(y[r], y[next(r)]);
else
b = floor(y[r] +
(y[next(r)] - y[r]) / (1.0 * x[next(r)] - x[r]) * (p - x[r]) +
eps);
return b - a;
}
inline int worky(int p, int l, int r) {
int a, b;
if (y[l] == y[pre(l)])
a = max(x[l], x[pre(l)]);
else
a = floor(x[l] +
(x[pre(l)] - x[l]) * (p - y[l]) / (1.0 * y[pre(l)] - y[l]));
if (y[r] == y[next(r)])
b = min(x[r], x[next(r)]) - 1;
else
b = ceil(x[r] +
(x[next(r)] - x[r]) * (p - y[r]) / (1.0 * y[next(r)] - y[r])) -
1;
return a - b;
}
inline void work() {
zc = 0;
for (long long i = 0; i <= 2 * ding; ++i)
if (a[i] > 0) {
z = i - ding;
zc += 1.0 * a[i] * z * z;
sum += a[i] * z;
}
ans += zc / (node * 1.0);
zc = 0;
for (long long i = 0; i <= 2 * ding; ++i)
if (a[i] > 0) {
z = i - ding;
zc += 1.0 * a[i] * z * (sum - z);
}
ans -= zc / (node * 1.0) / ((node - 1) * 1.0);
}
int main() {
scanf("%I64d", &n);
mi = 2 * ding;
for (int i = 1; i <= n; ++i) {
scanf("%I64d%I64d", &x[i], &y[i]);
if (x[i] + ding < mi) mi = x[i] + ding, l = i;
}
for (int i = 1; i <= n; ++i)
tx[i] = x[(i + l - 2) % n + 1], ty[i] = y[(i + l - 2) % n + 1];
for (int i = 1; i <= n; ++i) x[i] = tx[i], y[i] = ty[i];
if (y[2] < y[n])
for (int i = 2; i <= (n + 1) / 2; ++i)
swap(x[i], x[n - i + 2]), swap(y[i], y[n - i + 2]);
t = x[1];
r = l = 1;
for (int i = 1; i <= n - 1; ++i) {
if (x[pre(l)] <= x[next(r)]) {
for (int j = t; j < x[pre(l)]; ++j) a[j + ding] = workx(j, l, r);
l = pre(l);
t = x[l];
} else {
for (int j = t; j < x[next(r)]; ++j) a[j + ding] = workx(j, l, r);
r = next(r);
t = x[r];
}
}
a[x[l] + ding] = workx(x[l], next(l), r);
node = 0;
for (long long i = 0; i <= 2 * ding; ++i) node += a[i];
work();
memset(a, 0, sizeof(a));
sum = 0;
mi = 2 * ding;
for (int i = 1; i <= n; ++i)
if (y[i] + ding < mi) mi = y[i] + ding, l = i;
r = l;
t = y[l];
for (int i = 1; i <= n - 1; ++i) {
if (y[pre(l)] <= y[next(r)]) {
for (int j = t; j < y[pre(l)]; ++j) a[j + ding] = worky(j, l, r);
l = pre(l);
t = y[l];
} else {
for (int j = t; j < y[next(r)]; ++j) a[j + ding] = worky(j, l, r);
r = next(r);
t = y[r];
}
}
a[y[l] + ding] = worky(y[l], next(l), r);
work();
fans = ans;
printf("%.10lf", fans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
pair<int, int> A[1000005];
int N;
void Init() {
Get(N);
for (int i = 1; i <= N; i++) {
Get(A[i].first);
Get(A[i].second);
A[i].first += 1000005;
A[i].second += 1000005;
}
}
double Floor(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) /
(double)(A[Y].first - A[X].first) *
(double)(A[Y].second - A[X].second);
return floor(Y1 + 0);
}
double Ceil(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) /
(double)(A[Y].first - A[X].first) *
(double)(A[Y].second - A[X].second);
return ceil(Y1 - 0);
}
long long F[10000005];
double Ans;
void Calc() {
rotate(A + 1, min_element(A + 1, A + N + 1), A + N + 1);
A[N + 1] = A[1];
int Pos = max_element(A + 1, A + N + 1) - A;
int P = A[1].first, Q = A[Pos].first;
for (int i = P, k = 1; i <= Q; i++) {
for (; A[k + 1].first < i;) k++;
int Pos = Ceil(k, k + 1, i);
F[i] = -Pos + 1;
}
long long Cnt = 0;
long long SumX = 0;
for (int i = Q, k = Pos; i >= P; i--) {
for (; A[k + 1].first > i;) k++;
int Pos = Floor(k, k + 1, i);
F[i] += Pos;
Cnt += F[i];
SumX += (i - 1000005) * F[i];
}
double Ans0 = 0;
for (int i = Q; i >= P; i--)
Ans0 += (double)F[i] * (i - 1000005) * (i - 1000005) * Cnt;
Ans0 -= (double)SumX * SumX;
Ans0 /= ((double)(Cnt - 1) * Cnt);
Ans += Ans0;
}
void Work() {
double S = 0;
A[N + 1] = A[1];
for (int k = 1; k <= N + 1; k++)
S += (double)A[k].first * (double)A[k + 1].second -
(double)A[k].second * (double)A[k + 1].first;
if (S < 0) reverse(A + 1, A + N + 1);
Calc();
for (int k = 1; k <= N; k++) std::swap(A[k].first, A[k].second);
reverse(A + 1, A + N + 1);
Calc();
}
void Output() { printf("%.15lf\n", (double)Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct TPoint {
long long x, y;
TPoint(int x = 0, int y = 0) : x(x), y(y) {}
};
TPoint p[100011];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long lfloor(long long a, long long b);
long long lceil(long long a, long long b) {
if (a < 0) {
return -lfloor(-a, b);
}
return (a + b - 1) / b;
}
long long lfloor(long long a, long long b) {
if (a < 0) {
return -lceil(-a, b);
}
return a / b;
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%I64d%I64d", &p[i].x, &p[i].y);
}
p[N] = p[0];
long long S = 0;
for (int i = 0; i < N; ++i) {
S += (p[i + 1].y + p[i].y) * (p[i + 1].x - p[i].x);
}
if (S > 0) {
reverse(p, p + N);
p[N] = p[0];
}
S = std::abs(S);
long long bord = 0;
for (int i = 0; i < N; ++i) {
bord += gcd(abs(p[i + 1].x - p[i].x), abs(p[i + 1].y - p[i].y));
}
long long total = (S + bord + 2) / 2;
vector<TPoint> low, high, left, right;
int m = 0;
for (int i = 0; i < N; ++i) {
if (p[i].x < p[m].x || (p[i].x == p[m].x && p[i].y < p[m].y)) {
m = i;
}
}
low.push_back(p[m]);
for (int i = m + 1;; ++i) {
i = (i + N) % N;
if (p[i].x > p[(i + N - 1) % N].x) {
low.push_back(p[i]);
} else {
break;
}
}
m = 0;
for (int i = 0; i < N; ++i) {
if (p[i].x < p[m].x || (p[i].x == p[m].x && p[i].y > p[m].y)) {
m = i;
}
}
high.push_back(p[m]);
for (int i = m + N - 1;; --i) {
i = (i + N) % N;
if (p[i].x > p[(i + 1) % N].x) {
high.push_back(p[i]);
} else {
break;
}
}
m = 0;
for (int i = 0; i < N; ++i) {
if (p[i].y < p[m].y || (p[i].y == p[m].y && p[i].x < p[m].x)) {
m = i;
}
}
left.push_back(p[m]);
for (int i = m + N - 1;; --i) {
i = (i + N) % N;
if (p[i].y > p[(i + 1) % N].y) {
left.push_back(p[i]);
} else {
break;
}
}
m = 0;
for (int i = 0; i < N; ++i) {
if (p[i].y < p[m].y || (p[i].y == p[m].y && p[i].x > p[m].x)) {
m = i;
}
}
right.push_back(p[m]);
for (int i = m + 1;; ++i) {
i = (i + N) % N;
if (p[i].y > p[(i + N - 1) % N].y) {
right.push_back(p[i]);
} else {
break;
}
}
double ex2 = 0.0, ex = 0.0;
{
int li = 0, hi = 0;
for (int x = -1000001; x <= 1000001; ++x) {
if (x < low[0].x) {
continue;
}
if (x > low.back().x) {
break;
}
int l = low[li].y + lceil((x - low[li].x) * (low[li + 1].y - low[li].y),
(low[li + 1].x - low[li].x));
int r =
high[hi].y + lfloor((x - high[hi].x) * (high[hi + 1].y - high[hi].y),
(high[hi + 1].x - high[hi].x));
int p = (r - l + 1);
ex2 += (double)1.0 * p * x * x;
ex += (double)1.0 * p * x;
if (x == low[li + 1].x) {
++li;
}
if (x == high[hi + 1].x) {
++hi;
}
}
}
double ey2 = 0.0, ey = 0.0;
{
int li = 0, ri = 0;
for (int y = -1000001; y <= 1000001; ++y) {
if (y < left[0].y) {
continue;
}
if (y > left.back().y) {
break;
}
int l =
left[li].x + lceil((y - left[li].y) * (left[li + 1].x - left[li].x),
(left[li + 1].y - left[li].y));
int r = right[ri].x +
lfloor((y - right[ri].y) * (right[ri + 1].x - right[ri].x),
(right[ri + 1].y - right[ri].y));
int p = (r - l + 1);
ey2 += (double)1.0 * p * y * y;
ey += (double)1.0 * p * y;
if (y == left[li + 1].y) {
++li;
}
if (y == right[ri + 1].y) {
++ri;
}
}
}
ex2 /= total;
ex /= total;
ey2 /= total;
ey /= total;
double ans = ex2 - ex * ex + ey2 - ey * ey;
ans *= 1.0 * total / (total - 1);
printf("%.10lf", (double)ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e6 + 2e5;
const int N = M >> 1;
const int MX = 2e6;
const int D = 1e6;
double L[M], R[M];
int g[M];
struct pnt {
int x, y;
void input() { scanf("%d %d", &x, &y); }
} p[N];
int n;
double ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
p[i].input();
p[i].x += D, p[i].y += D;
}
function<void(int, double)> update = [&](int y, double x) {
L[y] = min(L[y], x);
R[y] = max(R[y], x);
};
for (int step = 0; step < 2; step++) {
for (int i = 0; i <= MX; i++) L[i] = M, R[i] = -1;
for (int i = 1; i <= n; i++) {
update(p[i].y, p[i].x);
int ni = i == n ? 1 : i + 1;
if (p[i].y == p[ni].y) continue;
double d = (p[ni].x - p[i].x) * 1.0 / (p[ni].y - p[i].y);
double cur;
cur = p[i].x;
for (int j = p[i].y + 1; j < p[ni].y; j++) {
cur += d;
update(j, cur);
}
cur = p[ni].x;
for (int j = p[ni].y + 1; j < p[i].y; j++) {
cur += d;
update(j, cur);
}
}
long long tot = 0;
for (int i = 0; i <= MX; i++) {
int lx = L[i] + 0.9999999;
int rx = R[i] + 0.0000001;
g[i] = rx >= lx ? rx - lx + 1 : 0;
tot += g[i];
}
double c = 0, d = 0, dd = 0;
for (int i = 0; i < MX; i++) {
double r = g[i] * 1.0 / (tot - 1);
d = d + dd + r;
dd = dd + r + r;
c = c + d;
ans += 1.0 * g[i + 1] / tot * c;
}
for (int i = 1; i <= n; i++) swap(p[i].x, p[i].y);
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct ww {
double x, s, t, sumy, sumyy;
} a[2000010];
int i, j, k, n, m;
int x[2000010], y[2000010];
double l[2000010], r[2000010], s, t, an;
inline void work(int x, int y, int xx, int yy) {
if (x > xx) swap(x, xx), swap(y, yy);
if (x == xx) {
l[x] = min(l[x], 0. + y);
r[x] = max(r[x], 0. + yy);
return;
}
int i;
for (i = x; i <= xx; i++) {
double k = 1. * (yy - y) * (i - x) / (xx - x) + y;
l[i] = min(l[i], k);
r[i] = max(r[i], k);
}
}
inline void Do() {
int i;
for (i = 0; i <= 2000010 - 1; i++) r[i] = 0, l[i] = 2000010;
for (i = 1; i <= n; i++) work(x[i], y[i], x[i + 1], y[i + 1]);
m = 0;
for (i = 0; i <= 2000010 - 1; i++)
if (l[i] < 2000010) {
int A = int(l[i] - (1e-11)) + 1, B = int(r[i] + (1e-11));
m++;
a[m].x = i;
a[m].s = B - A + 1;
a[m].t = a[m].x * a[m].s;
}
s = t = 0;
for (i = 1; i <= m; i++) s += a[i].s, t += a[i].t;
for (i = 1; i <= m; i++)
an += a[i].t * a[i].x * (s - a[i].s) - (a[i].t * (t - a[i].t));
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]), x[i] += 2000010 / 2, y[i] += 2000010 / 2;
x[n + 1] = x[1], y[n + 1] = y[1];
Do();
for (i = 1; i <= n + 1; i++) swap(x[i], y[i]);
Do();
an /= s * (s - 1);
printf("%.10lf\n", an);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100004, M = 2000004, P = 1000000;
struct rec {
int x, y;
} p[N], u[N], d[N];
int n, nu, nd, ul, ur, dl, dr, ly[M], ry[M], cnt[M];
double ans = 0;
bool b[N];
long long cross(int p0, int p1, int p2) {
return (long long)(p[p1].x - p[p0].x) * (p[p2].y - p[p0].y) -
(long long)(p[p1].y - p[p0].y) * (p[p2].x - p[p0].x);
}
void process() {
int i;
nu = nd = 0;
ul = ur = dl = dr = 1;
for (i = 1; i <= n; i++) {
if ((p[i].x < p[ul].x) || ((p[i].x == p[ul].x) && (p[i].y > p[ul].y)))
ul = i;
if ((p[i].x > p[ur].x) || ((p[i].x == p[ur].x) && (p[i].y > p[ur].y)))
ur = i;
if ((p[i].x < p[dl].x) || ((p[i].x == p[dl].x) && (p[i].y < p[dl].y)))
dl = i;
if ((p[i].x > p[dr].x) || ((p[i].x == p[dr].x) && (p[i].y < p[dr].y)))
dr = i;
}
if (cross(1, 2, 3) > 0) {
for (i = ul;; i = (i == 1) ? n : (i - 1)) {
u[++nu] = p[i];
if (i == ur) break;
}
for (i = dl;; i = (i == n) ? 1 : (i + 1)) {
d[++nd] = p[i];
if (i == dr) break;
}
} else {
for (i = ul;; i = (i == n) ? 1 : (i + 1)) {
u[++nu] = p[i];
if (i == ur) break;
}
for (i = dl;; i = (i == 1) ? n : (i - 1)) {
d[++nd] = p[i];
if (i == dr) break;
}
}
u[++nu] = p[ur];
d[++nd] = p[dr];
int lx = p[ul].x, rx = p[ur].x, pu = 1, pd = 1;
for (i = lx; i < rx; i++) {
if ((pu <= nu) && (i == u[pu + 1].x)) pu++;
if ((pd <= nd) && (i == d[pd + 1].x)) pd++;
ly[i + P] =
d[pd].y + ceil((i - d[pd].x) * ((double)(d[pd + 1].y - d[pd].y) /
(d[pd + 1].x - d[pd].x)) -
1e-6);
ry[i + P] =
u[pu].y + floor((i - u[pu].x) * ((double)(u[pu + 1].y - u[pu].y) /
(u[pu + 1].x - u[pu].x)) +
1e-6);
}
ry[rx + P] = u[nu].y;
ly[rx + P] = d[nd].y;
double ret = 0;
long long tot = 0;
for (i = lx; i <= rx; i++)
cnt[i - lx + 1] = ry[i + P] - ly[i + P] + 1, tot += cnt[i - lx + 1];
double s1 = cnt[1], s2 = cnt[1], s = 0;
for (i = 2; i <= rx - lx + 1; i++) {
s += s2;
s1 += cnt[i - 1] + cnt[i];
s2 += s1;
ret += s * cnt[i] / tot;
}
ans += ret / (tot - 1);
}
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d", &p[i].x, &p[i].y), b[i] = true;
for (i = 2; i < n; i++)
if (cross(i - 1, i, i + 1) == 0) b[i] = false;
if (cross(n - 1, n, 1) == 0) b[n] = false;
if (cross(n, 1, 2) == 0) b[1] = false;
int m = n;
n = ans = 0;
for (i = 1; i <= m; i++)
if (b[i]) p[++n] = p[i];
process();
for (i = 1; i <= n; i++) swap(p[i].x, p[i].y);
process();
printf("%.10lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 1000100 * 2, MMax = 101000;
int N;
int xmin, xmax, ymin, ymax;
pair<long double, long double> line[MMax];
pair<int, int> area[MMax], P1[MMax];
vector<long double> X[NMax], Y[NMax];
long double sum[NMax];
long double Ceil(long double a) { return ceil(a); }
long double Floor(long double a) { return floor(a); }
pair<long double, long double> P[MMax];
bool flag[NMax];
int main() {
scanf("%d", &N);
xmin = 100000000;
xmax = -100000000;
ymin = 100000000;
ymax = -100000000;
int minx = 100000000, miny = 100000000;
for (int i = 1; i <= N; i++) {
int first, second;
scanf("%d%d", &first, &second);
minx = min(minx, first);
miny = min(miny, second);
P1[i].first = first;
P1[i].second = second;
P[i].first = (long double)first;
P[i].second = (long double)second;
}
for (int i = 1; i <= N; i++)
P[i].first -= (long double)minx, P[i].second -= (long double)miny,
P1[i].first -= minx, P1[i].second -= miny;
for (int i = 1; i <= N; i++) {
xmin = min(xmin, P1[i].first);
ymin = min(ymin, P1[i].second);
xmax = max(xmax, P1[i].first);
ymax = max(ymax, P1[i].second);
}
if (P1[N].first == P1[1].first) flag[0] = 1;
for (int i = 1; i <= N; i++) {
int j = i + 1;
if (j > N) j = 1;
if (P1[i].first == P1[j].first) {
line[i].first = -1;
line[i].second = -1;
flag[i] = 1;
area[i].first = P1[i].first;
area[i].second = P1[j].first;
if (!flag[i - 1]) {
X[area[i].first].push_back(P[i].second);
}
if (P1[j].first != P1[(j % N) + 1].first)
X[area[i].first].push_back(P[j].second);
} else {
line[i].first = (P[j].second - P[i].second) / (P[j].first - P[i].first);
line[i].second = P[j].second - P[j].first * line[i].first;
area[i].first = P1[i].first;
area[i].second = P1[j].first;
if (area[i].first < area[i].second)
for (int j = flag[i - 1] ? (area[i].first + 1) : area[i].first;
j < area[i].second; j++)
X[j].push_back(line[i].first * (long double)j + line[i].second);
else
for (int j = flag[i - 1] ? (area[i].first - 1) : area[i].first;
j > area[i].second; j--)
X[j].push_back(line[i].first * (long double)j + line[i].second);
}
}
memset(flag, 0, sizeof(flag));
if (P1[N].second == P1[1].second) flag[0] = 1;
for (int i = 1; i <= N; i++) {
swap(P[i].first, P[i].second);
swap(P1[i].first, P1[i].second);
int j = i + 1;
if (j > N) j = 1;
swap(P[j].first, P[j].second);
swap(P1[j].first, P1[j].second);
if (P1[i].first == P1[j].first) {
line[i].first = -1;
line[i].second = -1;
flag[i] = 1;
area[i].first = P1[i].first;
area[i].second = P1[j].first;
if (!flag[i - 1]) Y[area[i].first].push_back(P[i].second);
if (P1[j].first != P1[(j % N) + 1].second)
Y[area[i].first].push_back(P[j].second);
} else {
line[i].first = (P[j].second - P[i].second) / (P[j].first - P[i].first);
line[i].second = P[j].second - P[j].first * line[i].first;
area[i].first = P1[i].first;
area[i].second = P1[j].first;
if (area[i].first < area[i].second)
for (int j = flag[i - 1] ? (area[i].first + 1) : area[i].first;
j < area[i].second; j++)
Y[j].push_back(line[i].first * (long double)j + line[i].second);
else
for (int j = flag[i - 1] ? (area[i].first - 1) : area[i].first;
j > area[i].second; j--)
Y[j].push_back(line[i].first * (long double)j + line[i].second);
}
swap(P[i].first, P[i].second);
swap(P[j].first, P[j].second);
swap(P1[i].first, P1[i].second);
swap(P1[j].first, P1[j].second);
}
for (int i = xmin; i <= xmax; i++) {
for (int j = 0; j < X[i].size(); j++)
if (X[i][j] <= 0 && -X[i][j] < 1e-8f || (X[i][j] >= 0 && X[i][j] < 1e-8f))
X[i][j] = +0.0;
sort(X[i].begin(), X[i].end());
vector<long double>::iterator it = unique(X[i].begin(), X[i].end());
X[i].resize(distance(X[i].begin(), it));
if (X[i].size() == 1) X[i].push_back(X[i][0]);
if (X[i][0] > X[i][1]) swap(X[i][0], X[i][1]);
X[i][0] = (long double)Ceil(X[i][0]);
X[i][1] = (long double)Floor(X[i][1]);
}
for (int i = ymin; i <= ymax; i++) {
for (int j = 0; j < Y[i].size(); j++)
if (Y[i][j] <= 0 && -Y[i][j] < 1e-8f || (Y[i][j] >= 0 && Y[i][j] < 1e-8f))
Y[i][j] = +0.0;
sort(Y[i].begin(), Y[i].end());
vector<long double>::iterator it = unique(Y[i].begin(), Y[i].end());
Y[i].resize(distance(Y[i].begin(), it));
if (Y[i].size() == 1) Y[i].push_back(Y[i][0]);
if (Y[i][0] > Y[i][1]) swap(Y[i][0], Y[i][1]);
Y[i][0] = (long double)Ceil(Y[i][0]);
Y[i][1] = (long double)Floor(Y[i][1]);
}
long double ret = 0, div = 0, cnt = 0, mul = 0, mul1 = 0;
for (int i = xmin; i <= xmax; i++)
mul += X[i][1] - X[i][0] + 1,
mul1 += (long double)i * (X[i][1] - X[i][0] + 1);
for (int i = xmin; i <= xmax; i++) {
div = div + X[i][1] - X[i][0] + 1;
long double tmp = mul - (X[i][1] - X[i][0] + 1),
tmp1 = mul1 - (long double)i * (X[i][1] - X[i][0] + 1.0);
ret =
ret + (X[i][1] - X[i][0] + 1.0) * (long double)i * (long double)i * tmp;
ret = ret - (X[i][1] - X[i][0] + 1.0) * (long double)i * tmp1;
}
cnt = 0;
mul = 0;
mul1 = 0;
for (int i = ymin; i <= ymax; i++)
mul += Y[i][1] - Y[i][0] + 1.0,
mul1 += (long double)i * (Y[i][1] - Y[i][0] + 1.0);
for (int i = ymin; i <= ymax; i++) {
long double tmp = mul - (Y[i][1] - Y[i][0] + 1.0),
tmp1 = mul1 - (long double)i * (Y[i][1] - Y[i][0] + 1.0);
ret =
ret + (Y[i][1] - Y[i][0] + 1.0) * (long double)i * (long double)i * tmp;
ret = ret - (Y[i][1] - Y[i][0] + 1.0) * (long double)i * tmp1;
}
div = div * (div - 1.0);
ret = ret / div;
printf("%.10lf\n", (double)ret);
getchar();
getchar();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Tpoint {
long long x, y;
const bool operator!=(Tpoint a) const { return (a.x != x) || (a.y != y); }
} P[100050];
struct Tline {
Tpoint p0, p1;
} L[100050];
double s1[2000050], s2[2000050], s3[2000050];
long long cnt[2000050];
int n, tot, m;
bool cmp(Tline a, Tline b) {
return (a.p0.x < b.p0.x) || ((a.p0.x == b.p0.x) && (a.p1.y < b.p1.y));
}
double work() {
Tpoint _p, _p0, _p1;
double ans;
long long i, A, B, _L, _R;
tot = 0;
for (i = 0; i <= n - 1; i++)
if (P[i].x != P[(i + 1) % n].x) {
tot++;
L[tot].p0 = P[i];
L[tot].p1 = P[(i + 1) % n];
if (L[tot].p0.x > L[tot].p1.x) {
swap(L[tot].p0, L[tot].p1);
}
}
sort(L + 1, L + tot + 1, cmp);
A = 1;
B = 2;
m = L[tot].p1.x - L[1].p0.x + 1;
cnt[1] = L[2].p0.y - L[1].p0.y + 1;
for (i = L[1].p0.x + 1; i <= L[tot].p1.x; i++) {
if (i > L[A].p1.x) {
_p = L[A].p1;
while (L[A].p0 != _p) A++;
}
_p0 = L[A].p0;
_p1 = L[A].p1;
if (_p0.y > _p1.y) swap(_p0, _p1);
_L = _p0.y + (llabs(i - _p0.x) * (_p1.y - _p0.y)) / llabs(_p1.x - _p0.x);
if ((llabs(i - _p0.x) * (_p1.y - _p0.y)) % llabs(_p1.x - _p0.x)) _L++;
if (i > L[B].p1.x) {
_p = L[B].p1;
while (L[B].p0 != _p) B++;
}
_p0 = L[B].p0;
_p1 = L[B].p1;
if (_p0.y > _p1.y) swap(_p0, _p1);
_R = _p0.y + (llabs(i - _p0.x) * (_p1.y - _p0.y)) / llabs(_p1.x - _p0.x);
cnt[i - L[1].p0.x + 1] = _R - _L + 1;
}
s1[0] = 0;
s2[0] = 0;
s3[0] = 0;
ans = 0;
for (i = 1; i <= m; i++) s1[i] = s1[i - 1] + cnt[i];
for (i = 1; i <= m; i++) s2[i] = s2[i - 1] + 2 * s1[i - 1] + cnt[i];
for (i = 1; i <= m; i++) s3[i] = s3[i - 1] + s2[i];
for (i = 1; i <= m; i++) ans += s3[i - 1] * cnt[i];
ans /= s1[m] * (s1[m] - 1);
return ans;
}
int main() {
double ans;
int i;
scanf("%d", &n);
for (i = 0; i <= n - 1; i++) {
scanf("%I64d%I64d", &P[i].x, &P[i].y);
P[i].x += 1000000;
P[i].y += 1000000;
}
ans = work();
for (i = 0; i <= n - 1; i++) swap(P[i].x, P[i].y);
ans += work();
printf("%.10lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
pair<int, int> A[1000005];
int N;
void Init() {
Get(N);
for (int i = 1; i <= N; i++) {
Get(A[i].first);
Get(A[i].second);
A[i].first += 1000005;
A[i].second += 1000005;
}
}
double Floor(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) /
(double)(A[Y].first - A[X].first) *
(double)(A[Y].second - A[X].second);
return floor(Y1 + 0);
}
double Ceil(int X, int Y, int P) {
double Y1 = A[X].second + (double)(P - A[X].first) /
(double)(A[Y].first - A[X].first) *
(double)(A[Y].second - A[X].second);
return ceil(Y1 - 0);
}
long long F[10000005];
double Ans;
void Calc() {
rotate(A + 1, min_element(A + 1, A + N + 1), A + N + 1);
A[N + 1] = A[1];
int Pos = max_element(A + 1, A + N + 1) - A;
int P = A[1].first, Q = A[Pos].first;
for (int i = P, k = 1; i <= Q; i++) {
for (; A[k + 1].first < i;) k++;
int Pos = Ceil(k, k + 1, i);
F[i] = -Pos + 1;
}
long long Cnt = 0;
long long SumX = 0;
for (int i = Q, k = Pos; i >= P; i--) {
for (; A[k + 1].first > i;) k++;
int Pos = Floor(k, k + 1, i);
F[i] += Pos;
Cnt += F[i];
SumX += (i - 1000005) * F[i];
}
double Ans0 = 0;
for (int i = Q; i >= P; i--)
Ans0 += (double)F[i] * (i - 1000005) * (i - 1000005) * Cnt;
Ans0 -= (double)SumX * SumX;
Ans0 /= ((double)(Cnt - 1) * Cnt);
Ans += Ans0;
}
void Work() {
long long S = 0;
A[N + 1] = A[1];
for (int k = 1; k <= N + 1; k++)
S += A[k].first * A[k + 1].second - A[k].second * A[k + 1].first;
if (S < 0) reverse(A + 1, A + N + 1);
Calc();
for (int k = 1; k <= N; k++) std::swap(A[k].first, A[k].second);
reverse(A + 1, A + N + 1);
Calc();
}
void Output() { printf("%.15lf\n", (double)Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
int x[N], y[N];
vector<int> vec[2];
int main() {
int n;
scanf("%d", &n);
auto prv = [&n](int x) { return (x - 1 + n) % n; };
auto nxt = [&n](int x) { return (x + 1) % n; };
for (int i = 0; i < n; i++) scanf("%d%d", &x[i], &y[i]);
for (int T = 0; T < 2; T++) {
if (T)
for (int i = 0; i < n; i++) swap(x[i], y[i]);
int id, miy = 1e8;
for (int i = 0; i < n; i++)
if (miy > y[i]) miy = y[i], id = i;
int lid = id, rid = id;
while (y[prv(lid)] == miy) lid = prv(lid);
while (y[nxt(rid)] == miy) rid = nxt(rid);
vec[T].push_back(abs(x[lid] - x[rid]) + 1);
int now_y = miy;
while (1) {
++now_y;
if (y[prv(lid)] == now_y) lid = prv(lid);
if (y[nxt(rid)] == now_y) rid = nxt(rid);
if (y[prv(lid)] <= y[lid]) {
vec[T].push_back(abs(x[lid] - x[rid]) + 1);
break;
}
double lx = (1.0 * x[lid] * (y[prv(lid)] - now_y) +
1.0 * x[prv(lid)] * (now_y - y[lid])) /
(y[prv(lid)] - y[lid]);
double rx = (1.0 * x[rid] * (y[nxt(rid)] - now_y) +
1.0 * x[nxt(rid)] * (now_y - y[rid])) /
(y[nxt(rid)] - y[rid]);
if (lx > rx) swap(lx, rx);
vec[T].push_back(floor(rx) - ceil(lx) + 1);
}
}
long long all = 0;
for (auto &t : vec[0]) all += t;
double ans = 0;
for (int T = 0; T < 2; T++) {
double sum0 = 0, sum1 = 0, sum2 = 0;
int k = 0;
for (auto &t : vec[T]) {
sum0 += t;
sum1 += 1.0 * k * t;
sum2 += 1.0 * k * k * t;
++k;
}
ans += 2 * sum2 * sum0 - 2 * sum1 * sum1;
}
printf("%.10lf\n", ans / all / (all - 1) / 2);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
int n;
int x[100000], y[100000];
double gao(int x[], int y[]) {
int leftMost = min_element(x, x + n) - x;
int minVal = *min_element(x, x + n);
int maxVal = *max_element(x, x + n);
int up1 = leftMost, up2 = (up1 + 1) % n;
int down1 = leftMost, down2 = (down1 + n - 1) % n;
double sqSum = 0.0;
double sum = 0.0;
double allCount = 0;
for (int i = minVal; i <= maxVal; ++i) {
if (i > x[up2]) {
up1 = up2;
up2 = (up2 + 1) % n;
}
if (i > x[down2]) {
down1 = down2;
down2 = (down2 + n - 1) % n;
}
int count = 0;
if (i == x[up2] && (x[up1] == x[up2] || x[up2] == x[(up2 + 1) % n])) {
count = 1 + (x[up1] == x[up2] ? abs(y[up1] - y[up2])
: abs(y[up2] - y[(up2 + 1) % n]));
} else if (i == x[down2] &&
(x[down1] == x[down2] || x[down2] == x[(down2 + n - 1) % n])) {
count =
1 + (x[down1] == x[down2] ? abs(y[down1] - y[down2])
: abs(y[down2] - y[(down2 + n - 1) % n]));
} else {
double ub =
(double)(y[up1] - y[up2]) / (x[up1] - x[up2]) * (i - x[up1]) + y[up1];
double db = (double)(y[down1] - y[down2]) / (x[down1] - x[down2]) *
(i - x[down1]) +
y[down1];
count = floor(ub + EPS) - ceil(db - EPS) + 1;
}
allCount += count;
sqSum += (double)i * i * count;
sum += (double)i * count;
}
return (allCount * sqSum - sum * sum) / (allCount * (allCount - 1) / 2);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i], &y[i]);
}
long long sgn = 0;
for (int i = 0; i < n && sgn == 0; ++i) {
int j = (i + 1) % n, k = (j + 1) % n;
sgn = (long long)(x[j] - x[i]) * (y[k] - y[i]) -
(long long)(x[k] - x[i]) * (y[j] - y[i]);
}
if (sgn > 0) {
reverse(x, x + n);
reverse(y, y + n);
}
double res = 0.0;
res += gao(x, y);
reverse(x, x + n);
reverse(y, y + n);
res += gao(y, x);
res /= 2;
printf("%.13f\n", res);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
point() { x = y = 0; }
point(long long _x, long long _y) { x = _x, y = _y; }
void read() { scanf("%I64d%I64d", &x, &y); }
point operator-(point &a) { return point(x - a.x, y - a.y); }
long long operator*(point a) { return x * a.y - y * a.x; }
} a[200005];
int n, l, r, p;
long double c[2000005], second[2000005], q[2000005];
long long up, down;
bool cmp(point &a, point &b) {
return ((a.x < b.x) || (a.x == b.x && a.y < b.y));
}
void Up(point &a, point &b, int i) {
if (a.x == b.x)
up = max(a.y, b.y);
else
up = (long long)floor((a.x - i + 0.0) * (a.y - b.y) / (b.x - a.x)) + a.y;
if (b.x == i) l = (l + 1) % n;
}
void Down(point &a, point &b, int i) {
if (a.x == b.x)
down = min(a.y, b.y);
else
down = (long long)ceil((a.x - i + 0.0) * (a.y - b.y) / (b.x - a.x)) + a.y;
if (b.x == i) r = (r - 1 + n) % n;
}
int main() {
scanf("%d", &n);
int L = 0, R = 0;
for (int i = 0; i < n; ++i) {
a[i].read();
a[i].x += 1000000;
a[i].y += 1000000;
}
long long S = 0;
for (int i = 0; i < n; ++i) S += (a[i] * a[(i + 1) % n]);
if (S > 0) reverse(a, a + n);
for (int i = 0; i < n; ++i) {
if (cmp(a[i], a[L])) L = i;
if (cmp(a[R], a[i])) R = i;
}
int M1 = a[L].x, M2 = a[R].x;
l = L, r = L;
long double a1 = 0;
for (int i = M1; i <= M2; ++i) {
int j = (l + 1) % n, k = (r - 1 + n) % n;
Up(a[l], a[j], i);
Down(a[r], a[k], i);
if (up + 1 < down) continue;
c[i] = up - down + 1.0;
second[i] = 1.0 * up * (up + 1) / 2 - 1.0 * down * (down - 1) / 2;
q[i] = 1.0 * up * (up + 1) * (2 * up + 1) / 6 -
1.0 * down * (down - 1) * (2 * down - 1) / 6;
a1 += c[i];
}
long double a2 = 0, a3 = 0, a4 = 0, a5 = 0;
for (int i = M1; i <= M2; ++i) {
a2 += q[i] / (a1 - 1), a3 += second[i];
a4 += c[i] * i * i / (a1 - 1), a5 += c[i] * i;
}
long double res =
(a2 + a4) - (a3 / (a1 - 1)) * (a3 / a1) - (a5 / (a1 - 1)) * (a5 / a1);
printf("%.15lf", (double)res);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int MAXM = 2e6 + 10;
const double eps = 1e-11;
int n, x[MAXN], y[MAXN];
double l[MAXM], r[MAXM];
void get(int x1, int y1, int x2, int y2) {
if (x1 > x2) swap(x1, x2), swap(y1, y2);
if (x1 == x2) {
l[x1] = min(l[x1], 1.0 * y1);
r[x1] = max(r[x1], 1.0 * y2);
} else {
for (int i = x1; i <= x2; ++i) {
double k = 1.0 * (y2 - y1) * (i - x1) / (x2 - x1) + y1;
l[i] = min(l[i], k);
r[i] = max(r[i], k);
}
}
}
int tot = 0;
double tx[MAXM], ts[MAXM], tss[MAXM], ans = 0, size, sum;
void work() {
for (int i = 0; i < MAXM; ++i) l[i] = 1e9, r[i] = 0;
for (int i = 0; i < n; ++i) get(x[i], y[i], x[(i + 1) % n], y[(i + 1) % n]);
tot = size = sum = 0;
for (int i = 0; i < MAXM; ++i)
if (l[i] < 1e8) {
int st = (int)(l[i] - eps) + 1, ed = (int)(r[i] + eps);
tx[tot] = i;
ts[tot] = ed - st + 1;
tss[tot] = tx[tot] * ts[tot];
tot++;
}
for (int i = 0; i < tot; ++i) size += ts[i], sum += tss[i];
for (int i = 0; i < tot; ++i)
ans += tss[i] * tx[i] * (size - ts[i]) - (tss[i] * (sum - tss[i]));
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i)
cin >> x[i] >> y[i], x[i] += MAXM / 2, y[i] += MAXM / 2;
work();
for (int i = 0; i < n; ++i) swap(x[i], y[i]);
work();
ans /= size * (size - 1);
printf("%.6lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
struct Point {
long long x, y;
bool operator<(const Point& o) const { return x < o.x; }
};
long long floor(long long a, long long b) {
return a >= 0 ? a / b : (a - b + 1) / b;
}
long long ceil(long long a, long long b) {
return a >= 0 ? (a + b - 1) / b : a / b;
}
long long floor(const Point& a, const Point& b, long long x) {
return a.y + floor((b.y - a.y) * (x - a.x), b.x - a.x);
}
long long ceil(const Point& a, const Point& b, long long x) {
return a.y + ceil((b.y - a.y) * (x - a.x), b.x - a.x);
}
double gao(vector<Point> v) {
int n = v.size();
int x1 = min_element(v.begin(), v.end())->x;
int x2 = max_element(v.begin(), v.end())->x;
vector<Point> y1, y2;
rotate(v.begin(), min_element(v.begin(), v.end()), v.end());
for (int i = 1;; ++i) {
if (y1.empty()) {
if (v[i].x > x1) {
y1.push_back(v[i - 1]);
} else {
continue;
}
}
y1.push_back(v[i]);
if (v[i].x == x2) {
break;
}
}
for (int i = n - 1;; --i) {
if (y2.empty()) {
if (v[i].x > x1) {
y2.push_back(v[(i + 1) % n]);
} else {
continue;
}
}
y2.push_back(v[i]);
if (v[i].x == x2) {
break;
}
}
if (y1[0].y > y2[0].y || (y1[0].y == y2[0].y && y1[1].y > y2[1].y)) {
swap(y1, y2);
}
vector<long long> x(x2 - x1 + 1, 0);
int k1 = 1, k2 = 1;
for (int i = x1; i <= x2; ++i) {
if (y1[k1].x < i) {
++k1;
}
if (y2[k2].x < i) {
++k2;
}
x[i - x1] = floor(y2[k2 - 1], y2[k2], i) - ceil(y1[k1 - 1], y1[k1], i) + 1;
}
long long cnt = 0, sx = 0;
for (int i = 0; i < (int)x.size(); ++i) {
cnt += x[i];
sx += i * x[i];
}
double sum = 0;
for (int i = 0; i < (int)x.size(); ++i) {
sum += (cnt - 1.0) * x[i] * i * i;
sum -= 1.0 * x[i] * i * (sx - i);
}
return sum / cnt / (cnt - 1);
}
int main() {
int n, x, y;
double ans = 0;
vector<Point> v;
scanf("%d", &n);
v.resize(n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
v[i].x = x;
v[i].y = y;
}
ans = gao(v);
for (int i = 0; i < n; ++i) {
swap(v[i].x, v[i].y);
}
ans += gao(v);
printf("%.10lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T LOW_BIT(T n);
template <class T>
inline int COUNT_BIT(T n);
template <class T>
inline T GCD(T a, T b);
template <class T>
inline T LCM(T a, T b);
bool isUpperCase(char c);
bool isLowerCase(char c);
bool isLetter(char c);
bool isDigit(char c);
char toLowerCase(char c);
char toUpperCase(char c);
template <class T>
string toString(T n);
template <class T>
void stoa(const string &s, int &n, T A[]);
template <class T>
void atos(int n, T A[], string &s);
template <class T>
void atov(int n, T A[], vector<T> &vi);
template <class T>
void vtoa(const vector<T> &vi, int &n, T A[]);
template <class T>
void stov(const string &s, vector<T> &vi);
template <class T>
void vtos(const vector<T> &vi, string &s);
template <class T>
inline vector<pair<T, int> > factorize(T n);
int64_t inverse_mod(int64_t a, int64_t mod);
string testCaseOutTemp = "Case #%d: ";
int numThread = 4;
void initProgram() {}
class Task {
public:
ostringstream out;
int testcase;
int N;
int X[100010];
int Y[100010];
int64_t lo[2 * 1000010];
int64_t hi[2 * 1000010];
int64_t a[2 * 1000010];
int64_t sum[2 * 1000010];
double T[2 * 1000010];
double P[2 * 1000010];
double Q[2 * 1000010];
int64_t area() {
int64_t a = 0, b = 0;
for (int i = 0, __e__ = (int)(N); i < __e__; ++i) {
a += int64_t(X[i]) * int64_t(Y[(i + 1) % N]);
b += int64_t(Y[i]) * int64_t(X[(i + 1) % N]);
}
return a - b;
}
void readInput() {
scanf("%d", &N);
for (int i = 0, __e__ = (int)(N); i < __e__; ++i) {
scanf("%d %d", X + i, Y + i);
X[i] += 1000010;
Y[i] += 1000010;
}
}
void pre() {
int64_t ar = area();
if (ar > 0) {
reverse(X, X + N);
reverse(Y, Y + N);
}
memset(lo, 0, sizeof lo);
for (int i = 0, __e__ = (int)(2 * 1000010); i < __e__; ++i) hi[i] = -1;
for (int i = 0, __e__ = (int)(N); i < __e__; ++i) {
int next = (i + 1) % N;
int64_t A = -(Y[i] - Y[next]);
int64_t B = (X[i] - X[next]);
int64_t C = A * int64_t(X[i]) + B * int64_t(Y[i]);
if (X[i] == X[next]) {
lo[X[i]] = min(Y[i], Y[next]);
hi[X[i]] = max(Y[i], Y[next]);
} else if (X[i] < X[next]) {
for (int x = (X[i]), __e__ = (int)(X[next]); x <= __e__; ++x) {
hi[x] = (-A * int64_t(x) + C) / B;
}
} else {
for (int x = (X[next]), __e__ = (int)(X[i]); x <= __e__; ++x) {
int64_t temp = (-A * int64_t(x) + C);
lo[x] = temp / B;
if (temp % B != 0) {
lo[x]++;
}
}
}
}
}
double calcs() {
for (int i = 0, __e__ = (int)(2 * 1000010); i < __e__; ++i) {
a[i] = hi[i] - lo[i] + 1LL;
}
sum[0] = a[0];
for (int i = (1), __e__ = (int)(2 * 1000010 - 1); i <= __e__; ++i) {
sum[i] = a[i] + sum[i - 1];
}
T[1] = a[0];
P[2] = a[1] + 3 * a[0];
T[2] = T[1] + P[2];
for (int i = (3), __e__ = (int)(2 * 1000010); i <= __e__; ++i) {
Q[i] = a[i - 1] + 2.0 * sum[i - 2];
P[i] = P[i - 1] + Q[i];
T[i] = T[i - 1] + P[i];
}
double ss = 0;
for (int i = (1), __e__ = (int)(2 * 1000010); i <= __e__; ++i) {
ss += (double)a[i] * T[i];
}
return ss;
}
void process() {
double ss = 0;
pre();
ss += calcs();
for (int i = 0, __e__ = (int)(N); i < __e__; ++i) {
swap(X[i], Y[i]);
}
pre();
ss += calcs();
int64_t cnt = sum[2 * 1000010 - 1];
out << fixed << ss / (double)cnt / (double)(cnt - 1LL);
}
};
int main() {
srand(time(0));
initProgram();
int ntest = 1;
{} {
for (int i = 0, __e__ = (int)(ntest); i < __e__; ++i) {
cerr << "processing test: " << i + 1 << endl;
Task *pT = new Task();
pT->testcase = i + 1;
pT->readInput();
pT->process();
cout << pT->out.str();
delete pT;
}
}
}
template <class T>
inline T LOW_BIT(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline int COUNT_BIT(T n) {
return (n == 0) ? 0 : (1 + COUNT_BIT(n & (n - 1)));
}
template <class T>
inline T GCD(T a, T b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (b == 0) ? a : GCD(b, a % b);
}
template <class T>
inline T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / GCD(a, b));
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
bool isLetter(char c) {
return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}
bool isDigit(char c) { return c >= '0' && c <= '9'; }
char toLowerCase(char c) { return (isUpperCase(c)) ? (c + 32) : c; }
char toUpperCase(char c) { return (isLowerCase(c)) ? (c - 32) : c; }
template <class T>
string toString(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
template <class T>
inline vector<pair<T, int> > factorize(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
void stoa(const string &s, int &n, T A[]) {
n = 0;
istringstream sin(s);
for (T v; sin >> v; A[n++] = v)
;
}
template <class T>
void atos(int n, T A[], string &s) {
ostringstream sout;
for (int i = 0; i < n; i++) {
if (i > 0) sout << ' ';
sout << A[i];
}
s = sout.str();
}
template <class T>
void atov(int n, T A[], vector<T> &vi) {
vi.clear();
for (int i = 0; i < n; i++) vi.push_back(A[i]);
}
template <class T>
void vtoa(const vector<T> &vi, int &n, T A[]) {
n = vi.size();
for (int i = 0; i < n; i++) A[i] = vi[i];
}
template <class T>
void stov(const string &s, vector<T> &vi) {
vi.clear();
istringstream sin(s);
for (T v; sin >> v; vi.push_bakc(v))
;
}
template <class T>
void vtos(const vector<T> &vi, string &s) {
ostringstream sout;
for (int i = 0; i < vi.size(); i++) {
if (i > 0) sout << ' ';
sout << vi[i];
}
s = sout.str();
}
struct extended_gcd_res {
int64_t x;
int64_t y;
extended_gcd_res(int64_t _x, int64_t _y) {
x = _x;
y = _y;
}
};
extended_gcd_res extended_gcd(int64_t a, int64_t b) {
if (b == 0)
return extended_gcd_res(1, 0);
else {
int64_t q = a / b;
int64_t r = a - b * q;
extended_gcd_res res = extended_gcd(b, r);
return extended_gcd_res(res.y, res.x - q * res.y);
}
}
int64_t inverse_mod(int64_t a, int64_t mod) {
extended_gcd_res res = extended_gcd(mod, a);
if (res.y < 0) res.y += mod;
return res.y;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int x[100001];
int y[100001];
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
int up(pair<int, int> a, pair<int, int> b, int c) {
long long p = (long long)a.second * (b.first - a.first) +
(long long)(b.second - a.second) * (c - a.first);
long long q = b.first - a.first;
if (p < 0) return p / q;
return (p + q - 1) / q;
}
int down(pair<int, int> a, pair<int, int> b, int c) {
long long p = (long long)a.second * (b.first - a.first) +
(long long)(b.second - a.second) * (c - a.first);
long long q = b.first - a.first;
if (p > 0) return p / q;
return (p - q + 1) / q;
}
double calc() {
int a = 0, b = 0, c = 0, d = 0;
for (int i = 0; i < n; i++) {
if (x[i] < x[a] || (x[i] == x[a] && y[i] < y[a])) a = i;
if (x[i] > x[b] || (x[i] == x[b] && y[i] < y[b])) b = i;
if (x[i] < x[c] || (x[i] == x[c] && y[i] > y[c])) c = i;
if (x[i] > x[d] || (x[i] == x[d] && y[i] > y[d])) d = i;
}
vector<pair<int, int> > v, w;
for (int i = a; i != b; i = (i + 1) % n) v.push_back(make_pair(x[i], y[i]));
v.push_back(make_pair(x[b], y[b]));
for (int i = d; i != c; i = (i + 1) % n) w.push_back(make_pair(x[i], y[i]));
w.push_back(make_pair(x[c], y[c]));
reverse((w).begin(), (w).end());
int i = 0, j = 0;
double s = 0, sx = 0, sxx = 0, ans = 0;
for (int c = x[a]; c <= x[b]; c++) {
while (v[i + 1].first < c) i++;
while (w[j + 1].first < c) j++;
int l = up(v[i], v[i + 1], c);
int r = down(w[j], w[j + 1], c);
int cur = r - l + 1;
ans += cur * (s * (c + 0.0) * c - 2 * sx * c + sxx);
s += cur;
sx += (c + 0.0) * cur;
sxx += ((c + 0.0) * (c + 0.0)) * cur;
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &x[i], &y[i]);
x[n] = x[0];
y[n] = y[0];
double sum = 0;
for (int i = 0; i < n; i++)
sum += (double)x[i] * y[i + 1] - (double)x[i + 1] * y[i];
if (sum < 0) {
reverse(x, x + n + 1);
reverse(y, y + n + 1);
sum = -sum;
}
sum /= 2;
double cnt = 0;
for (int i = 0; i < n; i++)
cnt += gcd(abs(x[i + 1] - x[i]), abs(y[i + 1] - y[i]));
cnt += (sum + 1 - cnt / 2);
double ans = calc();
for (int i = 0; i <= n; i++) swap(x[i], y[i]);
reverse(x, x + n + 1);
reverse(y, y + n + 1);
ans += calc();
printf("%.10f\n", ans / (cnt * (cnt - 1) / 2) / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e6 + 2e5;
const int N = M >> 1;
const int MX = 2e6;
const int D = 1e6;
double L[M], R[M];
int g[M];
struct pnt {
int x, y;
void input() { scanf("%d %d", &x, &y); }
} p[N];
int n;
double ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
p[i].input();
p[i].x += D, p[i].y += D;
}
function<void(int, double)> update = [&](int y, double x) {
L[y] = min(L[y], x);
R[y] = max(R[y], x);
};
for (int step = 0; step < 2; step++) {
for (int i = 0; i <= MX; i++) L[i] = M, R[i] = -1;
for (int i = 1; i <= n; i++) {
update(p[i].y, p[i].x);
int ni = i == n ? 1 : i + 1;
if (p[i].y == p[ni].y) continue;
double d = (p[ni].x - p[i].x) * 1.0 / (p[ni].y - p[i].y);
double cur;
cur = p[i].x;
for (int j = p[i].y + 1; j < p[ni].y; j++) {
cur += d;
update(j, cur);
}
cur = p[ni].x;
for (int j = p[ni].y + 1; j < p[i].y; j++) {
cur += d;
update(j, cur);
}
}
long long tot = 0;
for (int i = 0; i <= MX; i++) {
int lx = L[i] + 0.9999999;
int rx = R[i] + 0.0000001;
g[i] = rx >= lx ? rx - lx + 1 : 0;
tot += g[i];
}
double c = 0, d = 0, dd = 0;
for (int i = 0; i < MX; i++) {
double r = g[i] * 1.0 / (tot - 1);
d = d + dd + r;
dd = dd + r + r;
c = c + d;
ans += 1.0 * g[i + 1] / tot * c;
}
for (int i = 1; i <= n; i++) swap(p[i].x, p[i].y);
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int N, X[maxn], Y[maxn];
double S0, S1, S2;
int p(int x) {
int ret = (((x)-1 + N) % N);
while (X[ret] == X[x] && Y[ret] == Y[x]) ret = (((ret)-1 + N) % N);
return ret;
}
int s(int x) {
int ret = (((x) + 1) % N);
while (X[ret] == X[x] && Y[ret] == Y[x]) ret = (((ret) + 1) % N);
return ret;
}
bool Work(int x, int &uu, int &dd, int X[], int Y[]) {
int u, d;
if (uu != dd) {
u = (X[p(uu)] > X[s(uu)] ? p(uu) : s(uu));
d = (X[p(dd)] > X[s(dd)] ? p(dd) : s(dd));
} else if (Y[p(uu)] > Y[s(uu)])
u = p(uu), d = s(uu);
else
u = s(uu), d = p(uu);
if (x > X[u]) return false;
double t, b;
t = Y[uu] +
floorl((long double)(Y[u] - Y[uu]) * (x - X[uu]) / (X[u] - X[uu]));
b = Y[dd] + ceill((long double)(Y[d] - Y[dd]) * (x - X[dd]) / (X[d] - X[dd]));
S0 += t - b + 1;
S1 += (t - b + 1) * (t + b) / 2;
S2 += (t * (t + 1) * (2 * t + 1) - (b - 1) * b * (2 * b - 1)) / 6;
if (x == X[u]) uu = u;
if (x == X[d]) dd = d;
return true;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d%d", &X[i], &Y[i]);
int Lu(0), Ld(0), Dl(0), Dr(0);
for (int i = 1; i < N; i++) {
if (X[Lu] > X[i] || X[Lu] == X[i] && Y[Lu] < Y[i]) Lu = i;
if (X[Ld] > X[i] || X[Ld] == X[i] && Y[Ld] > Y[i]) Ld = i;
if (Y[Dl] > Y[i] || Y[Dl] == Y[i] && X[Dl] > X[i]) Dl = i;
if (Y[Dr] > Y[i] || Y[Dr] == Y[i] && X[Dr] < X[i]) Dr = i;
}
double ans = 0;
for (int x = X[Lu], uu = Lu, dd = Ld; Work(x, uu, dd, X, Y); x++)
;
ans += (S0 * S2 - S1 * S1) / (S0 * (S0 - 1)) * 2;
S0 = S1 = S2 = 0;
for (int y = Y[Dl], ll = Dl, rr = Dr; Work(y, rr, ll, Y, X); y++)
;
ans += (S0 * S2 - S1 * S1) / (S0 * (S0 - 1)) * 2;
printf("%.10f\n", ans / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const double eps = 1e-8, inf = 1e9;
int n, li_n, evt;
struct point {
double x, y;
void init() { scanf("%lf %lf", &x, &y); }
} p[N];
struct line {
point s, t;
double gety(double x) { return s.y + (x - s.x) / (t.x - s.x) * (t.y - s.y); }
} li[N];
struct event {
double t;
int id;
} ev[N * 2];
double minx, maxx;
int ii, jj;
double ans = 0.0;
bool dcmp(double a, double b) { return fabs(a - b) < eps; }
void addline(point s, point t) {
if (dcmp(s.x, t.x)) return;
if (t.x < s.x) swap(s, t);
li[++li_n] = (line){s, t};
ev[evt++] = (event){s.x, +li_n};
if (!dcmp(t.x, maxx)) ev[evt++] = (event){t.x, -li_n};
}
void deal(event e) {
if (e.id > 0) {
if (!ii)
ii = e.id;
else
jj = e.id;
} else {
if (ii == -e.id)
ii = 0;
else
jj = 0;
}
}
bool cmp_ev(const event& a, const event& b) {
if (dcmp(a.t, b.t)) return a.id < b.id;
return a.t < b.t;
}
void process() {
minx = inf, maxx = -inf;
p[0] = p[n];
for (int i = 1; i <= n; ++i) {
minx = min(minx, p[i].x);
maxx = max(maxx, p[i].x);
}
li_n = evt = 0;
for (int i = 1; i <= n; ++i) addline(p[i], p[i - 1]);
sort(ev, ev + evt, cmp_ev);
int evq = 0;
ii = jj = 0;
double sum = 0, gum = 0, tot = 0;
for (int x = minx; x <= maxx; ++x) {
while (evq != evt && dcmp(ev[evq].t, x)) deal(ev[evq++]);
if (!ii || !jj) ii = jj = 0;
double y0 = li[ii].gety(x);
double y1 = li[jj].gety(x);
if (y0 > y1) swap(y0, y1);
double cnt = floor(y1 + eps) - ceil(y0 - eps) + 1;
tot += cnt;
sum += cnt * x;
gum += cnt * x * x;
}
ans += 2.0 * gum / tot - 2.0 / tot / (tot - 1) * (sum * sum - gum);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) p[i].init();
process();
for (int i = 1; i <= n; ++i) swap(p[i].x, p[i].y);
process();
printf("%.10lf\n", ans / 2);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101010;
int n;
class Point {
public:
int x, y;
Point() {}
Point(int x, int y) : x(x), y(y) {}
Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
} a[MAXN];
double det(const Point &a, const Point &b) {
return 1.0 * a.x * b.y - 1.0 * a.y * b.x;
}
bool cmpx(const Point &a, const Point &b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
int maxx, minx, maxy, miny;
int minpos, mp1;
int gup1, gup2;
int gdw1, gdw2;
int cnt[2010101];
double sx, sx2;
double ans;
bool changed;
void solve() {
int cury1, cury2;
cury1 = cury2 = a[minpos].y;
gup1 = gdw1 = minpos;
gup2 = minpos + 1;
gdw2 = minpos - 1;
if (gup2 > n) gup2 -= n;
if (gdw2 < 1) gdw2 += n;
changed = false;
if (1.0 * (a[gup2].y - a[gup1].y + 1e-8) * (1e-8 + a[gdw2].x - a[gdw1].x) <
1.0 * (1e-8 + a[gdw2].y - a[gdw1].y) * (1e-8 + a[gup2].x - a[gup1].x))
changed = true;
Point now;
double cnt = 0;
sx = sx2 = 0;
bool flag = true, flag1 = true;
for (int x1 = minx; x1 <= maxx; ++x1) {
while ((x1 > a[gup2].x ||
(x1 != maxx && a[gup1].x == x1 && a[gup1].x == a[gup2].x))) {
gup1 = gup2;
gup2++;
if (gup2 > n) gup2 -= n;
}
while ((x1 > a[gdw2].x ||
(x1 != maxx && a[gdw1].x == a[gdw2].x && a[gdw1].x == x1))) {
gdw1 = gdw2;
gdw2--;
if (gdw2 < 1) gdw2 += n;
}
if (flag)
if (!changed && a[gup1].y > a[gup2].y)
flag = false;
else if (changed && a[gdw1].y > a[gdw2].y)
flag = false;
if (x1 == minx && !changed) {
cury1 = max(cury1, a[gup1].y);
cury2 = min(cury2, a[gdw1].y);
}
if (x1 == minx && changed) {
cury1 = max(cury1, a[gdw1].y);
cury2 = min(cury2, a[gup1].y);
}
if (flag1)
if (changed && a[gup1].y < a[gup2].y)
flag1 = false;
else if (!changed && a[gdw1].y < a[gdw2].y)
flag1 = false;
now.x = x1;
now.y = cury1;
if (!changed) {
if (flag) {
now.y++;
while (det(now - a[gup2], now - a[gup1]) >= 0) now.y++;
cury1 = now.y - 1;
} else {
while (det(now - a[gup2], now - a[gup1]) < 0) now.y--;
cury1 = now.y;
}
now.y = cury2;
if (flag1) {
now.y--;
while (det(now - a[gdw2], now - a[gdw1]) <= 0) now.y--;
cury2 = now.y + 1;
} else {
while (det(now - a[gdw2], now - a[gdw1]) > 0) now.y++;
cury2 = now.y;
}
} else {
if (flag) {
now.y++;
while (det(now - a[gdw2], now - a[gdw1]) >= 0) now.y++;
cury1 = now.y - 1;
} else {
while (det(now - a[gdw2], now - a[gdw1]) < 0) now.y--;
cury1 = now.y;
}
now.y = cury2;
if (flag1) {
now.y--;
while (det(now - a[gup2], now - a[gup1]) <= 0) now.y--;
cury2 = now.y + 1;
} else {
while (det(now - a[gup2], now - a[gup1]) > 0) now.y++;
cury2 = now.y;
}
}
sx2 += 1.0 * (cury1 - cury2 + 1) * x1 * x1;
sx += 1.0 * (cury1 - cury2 + 1) * x1;
cnt += cury1 - cury2 + 1;
}
double key;
key = sx * sx;
key -= sx2 * cnt;
key = -key;
key /= cnt * (cnt - 1) / 2;
ans += key;
}
int top, down;
int main() {
scanf("%d", &n);
maxx = maxy = -1010101;
minx = miny = 1010101;
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i].x, &a[i].y);
maxx = max(a[i].x, maxx);
if (a[i].x < minx) {
minpos = i;
minx = a[i].x;
}
maxy = max(a[i].y, maxy);
if (a[i].y < miny) {
mp1 = i;
miny = a[i].y;
}
}
solve();
for (int i = 1; i <= n; ++i) {
swap(a[i].x, a[i].y);
}
minpos = mp1;
minx = miny;
maxx = maxy;
solve();
printf("%.10lf\n", ans / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
double k, b;
friend double operator*(const point& A, const point& B) {
return 1.0 * A.x * B.y - 1.0 * A.y * B.x;
}
} a[100005];
int N, F[100005 * 20];
double ans, S;
void read(int& x) {
char c, n = 0;
for (; !isdigit(c = getchar());)
if (c == '-') n = 1;
for (x = 0; isdigit(c); c = getchar()) (x *= 10) += c - 48;
if (n) x = -x;
}
void init() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d%d", &a[i].x, &a[i].y);
}
void work() {
a[N + 1] = a[1], S = 0, memset(F, 0, sizeof(F));
double area = 0;
for (int i = 1; i <= N; i++) area += a[i] * a[i + 1];
if (area < -1e-9)
for (int i = 1; i + i <= N + 1; i++) swap(a[i], a[N + 2 - i]);
int mi = 1e9, ma = -1e9, l, r, t = 0;
auto inc = [&](int i) { return i < N ? i + 1 : 1; };
auto dec = [&](int i) { return i > 1 ? i - 1 : N; };
for (int i = 1; i <= N; i++) {
if (a[i].x < mi) mi = a[i].x, l = i;
if (a[i].x > ma) ma = a[i].x, r = i;
if (a[i].x != a[i + 1].x)
a[i].k = 1.0 * (a[i].y - a[i + 1].y) / (a[i].x - a[i + 1].x),
a[i].b = a[i].y - a[i].k * a[i].x;
else
F[a[i].x + int(1e6)] += abs(a[i].y - a[i + 1].y) + 1, a[i].k = 1e99;
}
for (int x = mi, i = l, j = l; x <= ma; x++) {
for (; dec(i) != r && a[dec(i)].x <= x; i = dec(i))
;
for (; inc(j) != r && a[inc(j)].x <= x; j = inc(j))
;
if (a[dec(i)].k >= 1e99 || a[j].k >= 1e99) continue;
F[x + int(1e6)] = floor(a[dec(i)].k * x + a[dec(i)].b + 1e-9) -
ceil(a[j].k * x + a[j].b - 1e-9) + 1;
}
double u = 0, v = 0, w = 0;
for (int i = 0; i <= 2e6; i++)
w += v, v += 2 * u + F[i], u += F[i], ans += w * F[i], S += F[i];
}
void doit() {
work();
for (int i = 1; i <= N; i++) swap(a[i].x, a[i].y);
work();
printf("%.9f\n", 1.0 * ans / S / (S - 1));
}
int main() {
init();
doit();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
long long ln, lk, lm;
int x[100005], y[100005];
vector<double> mpx[2000005], mpy[2000005];
void dd(int i, int j) {
int vx = x[j] - x[i], vy = y[j] - y[i];
if (vx == 0) {
mpx[x[i] + 1000000].push_back(y[i]);
mpx[x[i] + 1000000].push_back(y[j]);
} else {
for (int p = min(x[i], x[j]); p <= max(x[i], x[j]); p++) {
double t = 1.0 * (p - x[i]) * vy / vx + y[i];
mpx[p + 1000000].push_back(t);
}
}
if (vy == 0) {
mpy[y[i] + 1000000].push_back(x[i]);
mpy[y[i] + 1000000].push_back(x[j]);
} else {
for (int p = min(y[i], y[j]); p <= max(y[i], y[j]); p++) {
double t = 1.0 * (p - y[i]) * vx / vy + x[i];
mpy[p + 1000000].push_back(t);
}
}
}
vector<double> v;
double ans;
double total;
void cal() {
double tmp = 0;
vector<double> vl;
vl.push_back(v[0]);
tmp = v[0];
for (int i = 1; i < v.size(); i++) {
double g = tmp * 2 + vl.back() + v[i];
vl.push_back(g);
tmp += v[i];
}
tmp = 0;
for (int i = 1; i < v.size(); i++) {
tmp += vl[i - 1];
ans += v[i] * tmp;
}
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) {
scanf("%d%d", x + i, y + i);
}
for (int(i) = 0; (i) < (int)(n); (i)++) {
dd(i, (i + 1) % n);
}
for (int i = 0; i < 2000005; i++)
if (!mpx[i].empty()) {
vector<double> p = mpx[i];
sort(p.begin(), p.end());
int h = floor(max(p[0], p.back()));
int l = ceil(min(p[0], p.back()));
v.push_back(h - l + 1);
total += v.back();
}
cal();
v.clear();
for (int i = 0; i < 2000005; i++)
if (!mpy[i].empty()) {
vector<double> p = mpy[i];
sort(p.begin(), p.end());
int h = floor(max(p[0], p.back()));
int l = ceil(min(p[0], p.back()));
v.push_back(h - l + 1);
}
cal();
double gg = 1.0 * total * (total - 1);
printf("%.10lf\n", ans / gg);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double finf = 1e208, eps = 1e-9;
const int Maxn = 100005, MaxN = 2000005, N = 1000000, inf = 999999999 + 208;
int n;
double ans = 0, min_y[MaxN], max_y[MaxN];
double *miny = min_y + N, *maxy = max_y + N;
inline int get() {
bool f = 0;
char ch;
while (!isdigit(ch = getchar())) f |= ch == '-';
int v = ch - 48;
while (isdigit(ch = getchar())) v = v * 10 + ch - 48;
return f ? -v : v;
}
template <class T, class T2>
inline void gmin(T &x, const T2 &y) {
if (x > y) x = y;
}
template <class T, class T2>
inline void gmax(T &x, const T2 &y) {
if (x < y) x = y;
}
struct Point {
int x, y;
} p[Maxn];
double solve() {
int minx = inf, maxx = -inf;
for (int i = 1; i <= n; i++) gmin(minx, p[i].x), gmax(maxx, p[i].x);
for (int i = minx; i <= maxx; i++) miny[i] = finf, maxy[i] = -finf;
for (int i = 1; i <= n; i++) {
Point s = p[i], t = p[i == n ? 1 : i + 1];
if (s.x == t.x) {
gmin(miny[s.x], min(s.y, t.y));
gmax(maxy[s.x], max(s.y, t.y));
} else {
if (s.x > t.x) swap(s, t);
double y, a = 1. / (t.x - s.x);
for (int i = s.x; i <= t.x; i++) {
y = s.y + (i - s.x) * a * (t.y - s.y);
gmin(miny[i], y);
gmax(maxy[i], y);
}
}
}
double tot = 0, res = 0, s1 = 0, s2 = 0, s3 = 0, cnt;
for (int i = minx; i <= maxx; i++) {
tot += cnt = floor(maxy[i] + eps) - floor(miny[i] - eps);
res += cnt * (s1 * i * i - 2 * s2 * i + s3);
s1 += cnt;
s2 += cnt * i;
s3 += cnt * i * i;
}
res /= tot * (tot - 1) / 2;
return res;
}
int main() {
n = get();
for (int i = 1; i <= n; i++) p[i].x = get(), p[i].y = get();
ans += solve();
for (int i = 1; i <= n; i++) swap(p[i].x, p[i].y);
ans += solve();
printf("%.8lf\n", ans * 0.5);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[100005];
long long ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
int dx1 = b.first - a.first;
int dy1 = b.second - a.second;
int dx2 = c.first - a.first;
int dy2 = c.second - a.second;
return 1ll * dx1 * dy2 - 1ll * dy1 * dx2;
}
int cnt[2000005], low[2000005], high[2000005];
long long tot = 0;
long double solve() {
memset(low, 0x3f, sizeof(low));
memset(high, 0, sizeof(high));
long long tmp = 0;
for (int i = 0; i < n; i++) {
bool swp = 0;
if (a[i] > a[i + 1]) {
swp = 1;
swap(a[i], a[i + 1]);
}
if (a[i].first == a[i + 1].first) {
low[a[i].first] = a[i].second;
high[a[i].first] = a[i + 1].second;
} else {
for (int j = a[i].first; j <= a[i + 1].first; j++) {
double t = 1.0 * (j - a[i].first) / (a[i + 1].first - a[i].first);
double p = t * (a[i + 1].second - a[i].second) + a[i].second;
low[j] = min(low[j], (int)ceil(p - 1e-10));
high[j] = max(high[j], (int)floor(p + 1e-10));
}
}
if (swp) swap(a[i], a[i + 1]);
}
long double ret = 0;
tot = 0;
for (int i = 0; i <= 2000000; i++) {
cnt[i] = max(0, high[i] - low[i] + 1);
tot += cnt[i];
}
long double t0 = 0, t1 = 0, t2 = 0;
for (int j = 0; j <= 2000000; j++) {
t0 += 1.0 * cnt[j] * j * j;
t1 += -2.0 * cnt[j] * j;
t2 += 1.0 * cnt[j];
}
for (int i = 0; i <= 2000000; i++) {
ret += 1.0 * cnt[i] * t0;
ret += 1.0 * cnt[i] * i * t1;
ret += 1.0 * cnt[i] * i * i * t2;
}
ret /= 2;
return ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
a[i].first += 1000000;
a[i].second += 1000000;
}
a[n] = a[0];
double ret = solve();
for (int i = 0; i <= n; i++) {
swap(a[i].first, a[i].second);
}
ret += solve();
ret /= tot;
ret /= tot - 1;
printf("%.10f", ret);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long double eps = 1e-9;
const int maxn = (int)1e5 + 10;
struct pt {
long long x, y;
pt() : x(0), y(0) {}
pt(long long x, long long y) : x(x), y(y) {}
void read() { scanf("%I64d%I64d", &x, &y); }
};
inline pt operator+(pt p1, pt p2) { return pt(p1.x + p2.x, p1.y + p2.y); }
inline pt operator-(pt p1, pt p2) { return pt(p1.x - p2.x, p1.y - p2.y); }
inline long long vect(pt p1, pt p2) { return p1.x * p2.y - p1.y * p2.x; }
inline bool upper(pt left, pt right, pt p) {
return vect(right - left, p - left) > 0;
}
inline bool lower(pt left, pt right, pt p) {
return vect(right - left, p - left) < 0;
}
inline bool operator<(pt p1, pt p2) {
return make_pair(p1.x, p1.y) < make_pair(p2.x, p2.y);
}
inline long long sum(long long x) {
if (x > 0) return (x * (x + 1) * (2 * x + 1)) / 6;
if (x < 0) {
return -sum(-x - 1);
}
return 0;
}
pt a[maxn];
vector<int> up, down;
pt S;
long double S2 = 0;
long double N = 0;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; (i) < (n); ++i) a[i].read();
sort(a, a + n);
int xmin = a[0].x;
int xmax = a[n - 1].x;
up.push_back(0), down.push_back(0);
for (int i = 1; i < n - 1; i++) {
if (upper(a[0], a[n - 1], a[i]))
up.push_back(i);
else
down.push_back(i);
}
int iup = 0, idown = 0;
up.push_back(n - 1), down.push_back(n - 1);
while (a[up[iup]].x == a[0].x) iup += 1;
iup -= 1;
int downEnd = ((int)(down).size()) - 1;
while (a[down[downEnd]].x == a[n - 1].x) downEnd -= 1;
downEnd += 1;
long long ymin = 0, ymax = 0;
for (int x = xmin; x <= xmax; x++) {
if (x > xmin && x < xmax) {
while (!upper(a[up[iup]], a[up[iup + 1]], pt(x, ymax))) ymax += 1;
while (upper(a[up[iup]], a[up[iup + 1]], pt(x, ymax))) ymax -= 1;
while (!lower(a[down[idown]], a[down[idown + 1]], pt(x, ymin))) ymin -= 1;
while (lower(a[down[idown]], a[down[idown + 1]], pt(x, ymin))) ymin += 1;
} else if (x == xmin) {
ymin = a[0].y;
ymax = a[up[iup]].y;
} else if (x == xmax) {
ymax = a[n - 1].y;
ymin = a[down[downEnd]].y;
}
N += ymax - ymin + 1;
S = S + pt((ymax - ymin + 1) * x, ((ymax - ymin + 1) * (ymin + ymax)) >> 1);
S2 += (ymax - ymin + 1) * (long long)x * x + sum(ymax) - sum(ymin - 1);
if (a[up[iup + 1]].x == x) iup += 1;
if (a[down[idown + 1]].x == x) idown += 1;
}
long double RES =
(S2 - (S.x * (long double)S.x + S.y * (long double)S.y) / N) / (N - 1);
RES = RES;
printf("%.18lf\n", (double)RES);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
struct poi {
ll x, y;
poi operator-(poi p) { return {x - p.x, y - p.y}; }
bool operator<(poi p) const { return tie(x, y) < tie(p.x, p.y); }
ll cross(poi p) { return x * p.y - y * p.x; }
};
ll xmul(poi a, poi b, poi c) { return (b - a).cross(c - a); }
using vp = vector<poi>;
vp convex(vp v) {
sort(v.begin(), v.end());
vp r;
for (int i = 0; i < v.size(); i++) {
while (r.size() > 1 && xmul(*++r.rbegin(), v[i], *r.rbegin()) >= 0)
r.pop_back();
r.push_back(v[i]);
}
int d = r.size();
for (int i = (int)v.size() - 2; i >= 0; i--) {
while (r.size() > d && xmul(*++r.rbegin(), v[i], *r.rbegin()) >= 0)
r.pop_back();
if (i != 0) r.push_back(v[i]);
}
return r;
}
ll f(ll a, ll b) {
if (a >= 0) return a / b;
return a / b - bool(a % b);
}
ll g(ll a, ll b) { return f(a + b - 1, b); }
ld solve(vp v) {
v = convex(v);
v.push_back(v[0]);
vp up, down;
for (int i = 0; i < v.size(); i++)
if (!i || v[i].x > v[i - 1].x)
down.push_back(v[i]);
else
break;
while (v.back().x == (++v.rbegin())->x) v.pop_back();
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++)
if (!i || v[i].x > v[i - 1].x)
up.push_back(v[i]);
else
break;
int j = 0, k = 0;
vector<pii> xs;
ld c = 0, s = 0, s2 = 0;
for (int i = up[0].x; i <= up.back().x; i++) {
while (up[j + 1].x < i) j++;
while (down[k + 1].x < i) k++;
ll u = f((up[j + 1].y - up[j].y) * (i - up[j].x), up[j + 1].x - up[j].x) +
up[j].y;
ll d = g((down[k + 1].y - down[k].y) * (i - down[k].x),
down[k + 1].x - down[k].x) +
down[k].y;
xs.push_back({i, u - d + 1});
c += u - d + 1;
s += i * (u - d + 1);
s2 += ld(i) * i * (u - d + 1);
}
ld ret = 0;
for (pii p : xs) {
ret += ld(p.first) * p.first * c * p.second;
ret += -2.0L * p.first * s * p.second;
ret += s2 * p.second;
}
return ret / c / (c - 1);
}
int main() {
int n;
cin >> n;
vp v;
while (n--) {
poi p;
cin >> p.x >> p.y;
v.push_back(p);
}
ld ans = 0;
for (int t = 0; t < 2; t++) {
ans += solve(v);
for (auto &p : v) swap(p.x, p.y);
}
cout << fixed << setprecision(9) << ans / 2 << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
namespace orz {
const char *LL_SPECIFIER = "%I64d";
const long double eps = 1e-9;
inline void read(int &x) { scanf("%d", &x); }
inline void read(char *x) { scanf("%s", x); }
template <typename T1, typename T2>
inline void read(T1 &x1, T2 &x2) {
read(x1);
read(x2);
}
template <typename T1, typename T2, typename T3>
inline void read(T1 &x1, T2 &x2, T3 &x3) {
read(x1);
read(x2);
read(x3);
}
template <typename T1, typename T2, typename T3, typename T4>
inline void read(T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
read(x1);
read(x2);
read(x3);
read(x4);
}
inline void write(const int x) { printf("%d", x); }
inline void write(const long long x) { printf(LL_SPECIFIER, x); }
inline void write(const double x) { printf("%.15lf", x); }
inline void write(const long double x) { write((double)x); }
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
template <typename T>
inline std::set<T> &operator<<(std::set<T> &S, const T a) {
S.insert(a);
return S;
}
} // namespace orz
using namespace orz;
struct dat {
long double x, s, t, sy, sy2;
} a[2000086];
int n, x[100086], y[100086];
long double l[2000086], r[2000086], ss, st;
inline void work(int x, int y, int xx, int yy) {
if (x > xx) {
std::swap(x, xx);
std::swap(y, yy);
}
if (x == xx) {
if (y < l[x]) l[x] = y;
if (yy > r[x]) r[x] = yy;
} else
for (int cx = (x); cx <= (xx); ++cx) {
long double k = (double)(yy - y) * (cx - x) / (xx - x) + y;
if (k < l[cx]) l[cx] = k;
if (k > r[cx]) r[cx] = k;
}
}
inline long double go() {
long double ans = 0;
for (int i = (0); i < (2000086); ++i) {
l[i] = 2000086;
r[i] = 0;
}
for (int i = (1); i <= (n); ++i) work(x[i], y[i], x[i + 1], y[i + 1]);
int m = 0;
for (int i = (0); i < (2000086); ++i)
if (l[i] < 2000086) {
int L = (int)(l[i] - eps) + 1, R = (int)(r[i] + eps);
++m;
a[m].x = i;
a[m].s = R - L + 1;
a[m].t = a[m].x * a[m].s;
}
ss = 0;
st = 0;
for (int i = (1); i <= (m); ++i) {
ss += a[i].s;
st += a[i].t;
}
for (int i = (1); i <= (m); ++i)
ans += a[i].t * a[i].x * (ss - a[i].s) - a[i].t * (st - a[i].t);
return ans;
}
int main() {
read(n);
for (int i = (1); i <= (n); ++i) {
read(x[i], y[i]);
x[i] += 2000086 / 2;
y[i] += 2000086 / 2;
}
x[n + 1] = x[1];
y[n + 1] = y[1];
long double ans = 0;
ans += go();
for (int i = (1); i <= (n + 1); ++i) std::swap(x[i], y[i]);
ans = (ans + go()) / (ss * (ss - 1));
writeln(ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
struct Point {
int x, y;
} d[200005];
long double ans, s2, s1, s0;
int n;
void Work() {
int t = 1, l = 1, r = n + 1;
s2 = s1 = s0 = 0;
for (int i = 1; i <= n; i++)
if (d[i].x < d[t].x) t = i;
for (int i = 1; i < t; i++) d[i + n] = d[i];
for (int i = 1; i <= n; i++) d[i] = d[i + t - 1];
while (d[l + 1].x == d[1].x) l++;
while (d[r - 1].x == d[1].x) r--;
l++;
r--;
d[n + 1] = d[1];
for (int x = d[1].x;; x++) {
while (d[l].x < x && l <= r) l++;
if (l > r) break;
while (d[r].x < x) r--;
double ly = ((double)d[l].y - d[l - 1].y) / (d[l].x - d[l - 1].x) *
(x - d[l - 1].x) +
d[l - 1].y;
double ry = ((double)d[r].y - d[r + 1].y) / (d[r].x - d[r + 1].x) *
(x - d[r + 1].x) +
d[r + 1].y;
if (ly > ry) swap(ly, ry);
ans += s2 * (floor(ry + eps) - ceil(ly - eps) + 1);
s0 += floor(ry + eps) - ceil(ly - eps) + 1;
s1 += s0;
s2 += s1 * 2 - s0;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &d[i].x, &d[i].y);
Work();
for (int i = 1; i <= n; i++) d[i].x = -d[i].x;
Work();
for (int i = 1; i <= n; i++) swap(d[i].x, d[i].y);
Work();
for (int i = 1; i <= n; i++) d[i].x = -d[i].x;
Work();
printf("%.20Lf\n", (double)(ans * 0.5 / (s0 * s0 - s0)));
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int Min[(1 << 21)];
int Max[(1 << 21)];
int X[(1 << 21)];
int Y[(1 << 21)];
double f(int n) {
int i, j;
for (i = (0); i < ((1 << 21)); ++i) {
Min[i] = (1 << 21);
Max[i] = 0;
}
for (i = (0); i < (n); ++i) {
int x1 = X[i];
int y1 = Y[i];
int x2 = X[(i + 1) % n];
int y2 = Y[(i + 1) % n];
if (pair<int, int>(x1, y1) > pair<int, int>(x2, y2)) {
swap(x1, x2);
swap(y1, y2);
}
if (x1 == x2) {
Min[x1] = min(Min[x1], y1 - 1);
Max[x1] = max(Max[x1], y2 + 1);
continue;
}
for (j = (x1); j < (x2 + 1); ++j) {
long long l = x2 - j;
long long r = j - x1;
long long d = x2 - x1;
long long v = y1 * l + y2 * r;
Min[j] = min(Min[j], int((v - 1) / d));
Max[j] = max(Max[j], int((v + d) / d));
}
}
long double sum0 = 0;
long double sum1 = 0;
long double sum2 = 0;
for (i = (0); i < ((1 << 21)); ++i)
if (Min[i] < Max[i]) {
long long cnt = Max[i] - Min[i] - 1;
long long value = i;
sum0 += cnt;
sum1 += cnt * value;
sum2 += cnt * value * value;
}
return sum0 < 1.5 ? 0.0 : (sum2 * sum0 - sum1 * sum1) / (sum0 * (sum0 - 1));
}
int main() {
int n;
scanf("%d", &n);
int i, j;
for (i = (0); i < (n); ++i) scanf("%d%d", &X[i], &Y[i]);
for (i = (0); i < (n); ++i) {
X[i] += (1 << 21) / 2;
Y[i] += (1 << 21) / 2;
}
double res = 0;
for (i = (0); i < (2); ++i) {
res += f(n);
for (j = (0); j < (n); ++j) swap(X[j], Y[j]);
}
printf("%.11lf\n", res);
return 0;
};
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int N, X[maxn], Y[maxn];
double S0, S1, S2;
bool Work(int x, int &uu, int &dd, int X[], int Y[]) {
int u, d;
if (uu != dd) {
u = (X[(((uu)-1 + N) % N)] > X[(((uu) + 1) % N)] ? (((uu)-1 + N) % N)
: (((uu) + 1) % N));
d = (X[(((dd)-1 + N) % N)] > X[(((dd) + 1) % N)] ? (((dd)-1 + N) % N)
: (((dd) + 1) % N));
} else if (Y[(((uu)-1 + N) % N)] > Y[(((uu) + 1) % N)])
u = (((uu)-1 + N) % N), d = (((uu) + 1) % N);
else
u = (((uu) + 1) % N), d = (((uu)-1 + N) % N);
if (X[u] <= X[uu] || X[d] <= X[dd]) return false;
double t, b;
t = Y[uu] + floor(double(Y[u] - Y[uu]) * (x - X[uu]) / (X[u] - X[uu]));
b = Y[dd] + ceil(double(Y[d] - Y[dd]) * (x - X[dd]) / (X[d] - X[dd]));
S0 += t - b + 1;
S1 += (t - b + 1) * (t + b) / 2;
S2 += (t * (t + 1) * (2 * t + 1) - (b - 1) * b * (2 * b - 1)) / 6;
if (x == X[u]) uu = u;
if (x == X[d]) dd = d;
return true;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d%d", &X[i], &Y[i]);
int Lu(0), Ld(0), Dl(0), Dr(0);
for (int i = 1; i < N; i++) {
if (X[Lu] > X[i] || X[Lu] == X[i] && Y[Lu] < Y[i]) Lu = i;
if (X[Ld] > X[i] || X[Ld] == X[i] && Y[Ld] > Y[i]) Ld = i;
if (Y[Dl] > Y[i] || Y[Dl] == Y[i] && X[Dl] > X[i]) Dl = i;
if (Y[Dr] > Y[i] || Y[Dr] == Y[i] && X[Dr] < X[i]) Dr = i;
}
double ans = 0;
for (int x = X[Lu], uu = Lu, dd = Ld; Work(x, uu, dd, X, Y); x++)
;
ans += (S0 * S2 - S1 * S1) / (S0 * (S0 - 1)) * 2;
S0 = S1 = S2 = 0;
for (int y = Y[Dl], ll = Dl, rr = Dr; Work(y, rr, ll, Y, X); y++)
;
ans += (S0 * S2 - S1 * S1) / (S0 * (S0 - 1)) * 2;
printf("%.10f\n", ans / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
struct Point {
int x, y;
int read() {
int ok = scanf("%d%d", &x, &y);
return ok == 2;
}
Point() {}
Point(int _x, int _y) : x(_x), y(_y) {}
inline Point operator-(const Point &p) const {
return Point(x - p.x, y - p.y);
}
inline long long operator^(const Point &p) const {
return (long long)x * p.y - (long long)y * p.x;
}
inline bool operator<(const Point &p) const {
if (y != p.y) return y < p.y;
return x < p.x;
}
inline bool operator==(const Point &p) const { return x == p.x && y == p.y; }
};
const int maxc = (int)1e6;
int tmpCnts[maxc * 2 + 1], *cnts = tmpCnts + maxc + 1;
inline double get(const Point &p1, const Point &p2, int y) {
return p1.x + (p2.x - p1.x) * (y - p1.y + 0.0) / (p2.y - p1.y);
}
double solve(Point *ps, int n) {
rotate(ps, min_element(ps, ps + n), ps + n);
ps[n] = ps[0];
long long S = 0;
for (int i = 0; i < n; i++) S += ps[i] ^ ps[i + 1];
if (S < 0) reverse(ps + 1, ps + n), S = -S;
int n0 = n;
n = 0;
for (int i = 0; i <= n0; i++) {
if (n && ps[i] == ps[n - 1]) continue;
if (n >= 2 && !((ps[n - 1] - ps[n - 2]) ^ (ps[i] - ps[n - 2]))) --n;
ps[n++] = ps[i];
}
--n;
int miny = maxc, maxy = -maxc;
for (int i = 0; i < n; i++)
miny = min(miny, ps[i].y), maxy = max(maxy, ps[i].y);
assert(ps[0].y == miny);
ps[n] = ps[0];
{
long long Sn = 0;
for (int i = 0; i < n; i++) Sn += ps[i] ^ ps[i + 1];
assert(S == Sn);
ps[n + 1] = ps[1];
for (int i = 0; i < n; i++)
assert((ps[i] - ps[i + 1]) ^ (ps[i] - ps[i + 2]));
}
double ans = 0;
long long sum = 0, cntSum = 0;
for (int y = miny, left = n, right = 0; y <= maxy; ++y) {
while (left > 0 && ps[left - 1].y < y) --left;
while (right < n && ps[right + 1].y < y) ++right;
assert(left > 0 && right < n);
int minx = (ps[left].y == ps[left - 1].y
? min(ps[left].x, ps[left - 1].x)
: ceil(get(ps[left], ps[left - 1], y) - (1e-9)));
int maxx = (ps[right].y == ps[right + 1].y
? max(ps[right].x, ps[right + 1].x)
: floor(get(ps[right], ps[right + 1], y) + (1e-9)));
assert(maxx >= minx - 1);
cnts[y] = maxx - minx + 1;
sum += (long long)cnts[y] * y;
ans += (long long)cnts[y] * y * y;
cntSum += cnts[y];
}
if (cntSum < 2) return 0;
ans -= (double)sum * sum / cntSum;
ans /= cntSum - 1;
ans *= 2;
return ans;
}
const int maxn = (int)1e5;
Point ps[maxn + 2], ps0[maxn];
int main() {
srand(rdtsc());
int n;
while (scanf("%d", &n) >= 1) {
for (int i = 0; i < n; i++) assert(ps0[i].read());
double ans = 0;
for (int coord = 0; coord < 2; coord++) {
memcpy(ps, ps0, sizeof(ps[0]) * n);
ans += solve(ps, n);
for (int i = 0; i < n; i++) swap(ps0[i].x, ps0[i].y);
}
ans /= 2;
printf("%.18lf\n", ans);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int co = 1000010;
const int N = 6 * co + 10;
long long yN[N], yd[N];
long long bn[42], bd[42];
int pred[N];
int last[2 * co + 10];
int x[100010], y[100010];
int m;
void add(int xa, int ya, int xb, int yb) {
if (xa == xb) return;
if (xa > xb) {
int tmp = xa;
xa = xb;
xb = tmp;
tmp = ya;
ya = yb;
yb = tmp;
}
for (int xx = xa; xx <= xb; xx++) {
m++;
yN[m] = (long long)ya * (xb - xa) + (long long)(yb - ya) * (xx - xa);
yd[m] = xb - xa;
pred[m] = last[xx + co];
last[xx + co] = m;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d %d", x + i, y + i);
double ans = 0.0;
for (int r = 0; r < 2; r++) {
x[n] = x[0];
y[n] = y[0];
m = 0;
for (int i = 0; i <= 2 * co; i++) last[i] = 0;
for (int i = 0; i < n; i++) add(x[i], y[i], x[i + 1], y[i + 1]);
double sum = 0, sq = 0, cnt = 0;
for (int xx = -co; xx <= co; xx++) {
int k = 0;
int j = last[xx + co];
while (j > 0) {
bn[k] = yN[j];
bd[k] = yd[j];
k++;
j = pred[j];
}
if (k == 0) continue;
for (int i = 0; i < k; i++)
for (int j = i + 1; j < k; j++)
if (bn[i] * bd[j] > bn[j] * bd[i]) {
long long tmp = bn[i];
bn[i] = bn[j];
bn[j] = tmp;
tmp = bd[i];
bd[i] = bd[j];
bd[j] = tmp;
}
long long up = bn[k - 1] / bd[k - 1];
while (up * bd[k - 1] > bn[k - 1]) up--;
while ((up + 1) * bd[k - 1] <= bn[k - 1]) up++;
long long down = bn[0] / bd[0];
while (down * bd[0] < bn[0]) down++;
while ((down - 1) * bd[0] >= bn[0]) down--;
cnt += 1.0 * (up - down + 1);
sum += 1.0 * xx * (up - down + 1);
sq += 1.0 * xx * xx * (up - down + 1);
}
ans += (sq - sum * sum / cnt) / (cnt - 1);
for (int i = 0; i < n; i++) {
int tmp = x[i];
x[i] = y[i];
y[i] = tmp;
}
}
printf("%.17lf\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 100000;
const int INF = 0x3f3f3f3f;
struct Point {
int x, y;
};
inline Point operator-(const Point& a, const Point& b) {
Point ans;
ans.x = a.x - b.x;
ans.y = a.y - b.y;
return ans;
}
inline long long det(const Point& a, const Point& b) {
return (long long)a.x * b.y - a.y * b.x;
}
int minn, maxn;
int n;
Point data[MAX_SIZE * 2 + 10];
long double xsqtot, ysqtot, xtot, ytot;
long long cnt;
inline void update(int x, int l, int r) {
if (l > r) return;
cnt += r - l + 1;
xsqtot += (long double)x * x * (r - l + 1);
ysqtot += ((long double)r * (r + 1) * ((r << 1) + 1) -
(long double)(l - 1) * l * (((l - 1) << 1) + 1)) /
6.0;
xtot += (long double)x * (r - l + 1);
ytot += (long double)(l + r) * (r - l + 1) / 2.0;
}
inline void findRange(int x, int& low, int& high) {
low = INF;
high = -INF;
for (int i = 1; i <= n; i++)
if (data[i].x == x) {
if (data[i].y < low) low = data[i].y;
if (data[i].y > high) high = data[i].y;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &data[i].x, &data[i].y);
data[i].y += 1000001;
}
long long tot = 0;
for (int i = 2; i < n; i++)
tot += det(data[i] - data[1], data[i + 1] - data[i]);
if (tot < 0) reverse(data + 1, data + n + 1);
minn = INF;
maxn = -INF;
for (int i = 1; i <= n; i++) {
if (data[i].x < minn) minn = data[i].x;
if (data[i].x > maxn) maxn = data[i].x;
}
int L = 1, R = n;
while (data[L].x != maxn) data[++R] = data[L++];
data[++R] = data[L];
int mid;
for (mid = L; data[mid].x != minn; mid++)
;
int pl = mid, pr = mid;
for (int x = minn; x <= maxn; x++) {
int high, low;
if (x == minn || x == maxn)
findRange(x, low, high);
else {
while (pl > L && data[pl].x <= x) --pl;
while (pr < R && data[pr].x <= x) ++pr;
high = (int)(((long long)(x - data[pl + 1].x) *
(data[pl].y - data[pl + 1].y) +
(long long)data[pl + 1].y * (data[pl].x - data[pl + 1].x)) /
(data[pl].x - data[pl + 1].x));
low = (int)(((long long)(x - data[pr - 1].x) *
(data[pr].y - data[pr - 1].y) +
(long long)data[pr - 1].y * (data[pr].x - data[pr - 1].x)) /
(data[pr].x - data[pr - 1].x) +
((long long)(x - data[pr - 1].x) *
(data[pr].y - data[pr - 1].y) %
(data[pr].x - data[pr - 1].x) !=
0));
}
update(x, low, high);
}
long double ans =
((xsqtot + ysqtot) -
((xtot * xtot - xsqtot) + (ytot * ytot - ysqtot)) / (cnt - 1)) /
cnt;
printf("%.10f\n", (double)ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
} high, low, st, en, temp_up, temp_down;
int n, k;
long long cntx[2000002], cnty[2000002], total = 0;
vector<point> v, up, down;
long long check(point a, point b, point c) {
return 1ll * (b.x - a.x) * (c.y - a.y) - 1ll * (b.y - a.y) * (c.x - a.x);
}
signed main() {
scanf("%d", &n);
for (int i = 1, x, y; i <= n; i++) {
scanf("%d %d", &x, &y);
v.push_back({x + 1000000, y + 1000000});
}
sort(v.begin(), v.end(),
[](point a, point b) { return a.x < b.x || (a.x == b.x && a.y < b.y); });
st = v[0], en = v.back();
for (int i = 0; i < (int)v.size(); i++) {
if (i != (int)v.size() - 1 && check(v[i], st, en) < 0) continue;
while (up.size() > 2 &&
check(up[up.size() - 1], up[up.size() - 2], v[i]) < 0) {
up.pop_back();
}
up.push_back(v[i]);
}
for (int i = 0; i < (int)v.size(); i++) {
if (i != (int)v.size() - 1 && check(v[i], st, en) > 0) continue;
while (down.size() > 2 &&
check(down[down.size() - 1], down[down.size() - 2], v[i]) > 0) {
down.pop_back();
}
down.push_back(v[i]);
}
high = low = {v[0].x + 1, v[0].y};
int cur = 0, mn = v[0].y, mx = v[0].y;
while (1) {
cur++;
if (v[cur].x == v[cur - 1].x) {
mx = max(mx, v[cur].y);
mn = min(mn, v[cur].y);
} else {
break;
}
}
high.y = mx;
low.y = mn;
cntx[v[0].x] = high.y - low.y + 1;
while (high.x <= v.back().x && low.x <= v.back().x) {
int k = lower_bound(up.begin(), up.end(), (point){high.x, 0},
[](point a, point b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}) -
up.begin();
temp_up = high;
while (check(up[k - 1], up[k], temp_up) <= 0) {
high = temp_up;
temp_up.y++;
}
while (check(up[k - 1], up[k], high) > 0) {
temp_up.y--;
high = temp_up;
}
k = lower_bound(down.begin(), down.end(), (point){low.x, 0},
[](point a, point b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}) -
down.begin();
temp_down = low;
while (check(down[k - 1], down[k], temp_down) >= 0) {
low = temp_down;
temp_down.y--;
}
while (check(down[k - 1], down[k], temp_down) < 0) {
temp_down.y++;
low = temp_down;
}
cntx[high.x] = high.y - low.y + 1;
high.x++;
low.x++;
}
up.clear();
down.clear();
sort(v.begin(), v.end(),
[](point a, point b) { return a.y < b.y || (a.y == b.y && a.x < b.x); });
st = v[0], en = v.back();
for (int i = 0; i < (int)v.size(); i++) {
if (i != (int)v.size() - 1 && check(v[i], st, en) < 0) continue;
while (up.size() > 2 &&
check(up[up.size() - 1], up[up.size() - 2], v[i]) < 0) {
up.pop_back();
}
up.push_back(v[i]);
}
for (int i = 0; i < (int)v.size(); i++) {
if (i != (int)v.size() - 1 && check(v[i], st, en) > 0) continue;
while (down.size() > 2 &&
check(down[down.size() - 1], down[down.size() - 2], v[i]) > 0) {
down.pop_back();
}
down.push_back(v[i]);
}
high = low = {v[0].x, v[0].y + 1};
cur = 0, mn = v[0].x, mx = v[0].x;
while (1) {
cur++;
if (v[cur].y == v[cur - 1].y) {
mx = max(mx, v[cur].x);
mn = min(mn, v[cur].x);
} else {
break;
}
}
low.x = mx;
high.x = mn;
cnty[v[0].y] = low.x - high.x + 1;
total += cnty[v[0].y];
while (high.y <= v.back().y && low.y <= v.back().y) {
k = lower_bound(up.begin(), up.end(), (point){0, high.y},
[](point a, point b) {
return a.y < b.y || (a.y == b.y && a.x < b.x);
}) -
up.begin();
point temp_up = high, temp_down = low;
while (check(up[k - 1], up[k], temp_up) <= 0) {
high = temp_up;
temp_up.x--;
}
while (check(up[k - 1], up[k], high) > 0) {
temp_up.x++;
high = temp_up;
}
k = lower_bound(down.begin(), down.end(), (point){0, low.y},
[](point a, point b) {
return a.y < b.y || (a.y == b.y && a.x < b.x);
}) -
down.begin();
while (check(down[k - 1], down[k], temp_down) >= 0) {
low = temp_down;
temp_down.x++;
}
while (check(down[k - 1], down[k], temp_down) < 0) {
temp_down.x--;
low = temp_down;
}
cnty[high.y] = low.x - high.x + 1;
total += cnty[high.y];
high.y++;
low.y++;
}
long long sumx = 0, sumy = 0;
long double sumx_square = 0, sumy_square = 0;
long double ansx = 0, ansy = 0;
for (long long j = 0; j <= 2e6; j++) {
sumx += j * cntx[j];
sumx_square += (long double)j * j / (total - 1) / 2 * cntx[j];
sumy += j * cnty[j];
sumy_square += (long double)j * j / (total - 1) / 2 * cnty[j];
}
for (long long i = 0; i <= 2e6; i++) {
ansx += (long double)(i * total - 2ll * sumx) / total * i / (total - 1) *
cntx[i] / 2;
ansy += (long double)(i * total - 2ll * sumy) / total * i / (total - 1) *
cnty[i] / 2;
}
ansx += sumx_square;
ansy += sumy_square;
long double t = ansx + ansy;
printf("%.10Lf\n", t);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100100][2];
long long round_ud(long long p, long long q, int dir) {
long long r = p / q, t = p % q;
if (t == 0) return r;
if (dir) {
if (t < 0)
return r;
else
return r + 1;
} else {
if (t < 0)
return r - 1;
else
return r;
}
}
int main() {
int l[2] = {-1, -1}, r[2] = {-1, -1};
int n, m = 0;
double sum[2] = {}, p1[2] = {}, p2[2] = {}, p0[2] = {}, cnt = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
scanf("%d", &a[i][j]);
if (l[j] < 0 || a[i][j] < a[l[j]][j]) l[j] = i;
if (r[j] < 0 || a[i][j] > a[r[j]][j]) r[j] = i;
}
}
for (int j = 0; j < 2; j++) {
int s[2] = {l[j], l[j]}, mv[2] = {1, n - 1};
for (int k = 0; k < 2; k++) {
while (a[(s[k] + mv[k]) % n][j] == a[s[k]][j]) s[k] = (s[k] + mv[k]) % n;
}
double sc = abs(a[s[1]][j ^ 1] - a[s[0]][j ^ 1]) + 1;
cnt += sc * (sc - 1) / 2;
p0[j] = sc;
p1[j] = sc * a[l[j]][j];
p2[j] = sc * a[l[j]][j] * a[l[j]][j];
for (int x = a[l[j]][j] + 1; x <= a[r[j]][j]; x++) {
long long p[2], q[2];
for (int k = 0; k < 2; k++) {
while (a[s[k]][j] < x && a[(s[k] + mv[k]) % n][j] <= x)
s[k] = (s[k] + mv[k]) % n;
int px = a[s[k]][j], py = a[s[k]][j ^ 1];
int nx = a[(s[k] + mv[k]) % n][j], ny = a[(s[k] + mv[k]) % n][j ^ 1];
if (x == px)
p[k] = py, q[k] = 1;
else {
p[k] = 1LL * py * (nx - px) + 1LL * (x - px) * (ny - py);
q[k] = nx - px;
}
}
int large = 0;
if (p[0] * q[1] < p[1] * q[0]) large = 1;
double ty[2];
for (int k = 0; k < 2; k++) {
ty[k] = round_ud(p[k], q[k], k ^ large);
}
sc = ty[large] - ty[large ^ 1] + 1;
sum[j] += sc * (p2[j] - 2 * p1[j] * x + p0[j] * x * x);
cnt += sc * p0[j] + sc * (sc - 1) / 2;
p0[j] += sc;
p1[j] += sc * x;
p2[j] += sc * x * x;
}
}
printf("%.8f\n", 1.0 * (sum[0] + sum[1]) / cnt);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y;
point() { x = y = 0; }
point(double _x, double _y) { x = _x, y = _y; }
void read() { scanf("%lf%lf", &x, &y); }
point operator-(point &a) { return point(x - a.x, y - a.y); }
double operator*(point a) { return x * a.y - y * a.x; }
} a[200005];
int n, l, r, p;
double up, down, c[2000005], second[2000005], q[2000005];
bool cmp(point &a, point &b) {
return ((a.x < b.x) || (a.x == b.x && a.y < b.y));
}
void Up(point &a, point &b, int i) {
if (a.x == b.x)
up = max(a.y, b.y);
else
up = floor((a.x - i) * (a.y - b.y) / (b.x - a.x)) + a.y;
if (b.x == i) l = (l + 1) % n;
}
void Down(point &a, point &b, int i) {
if (a.x == b.x)
down = min(a.y, b.y);
else
down = ceil((a.x - i) * (a.y - b.y) / (b.x - a.x)) + a.y;
if (b.x == i) r = (r - 1 + n) % n;
}
int main() {
scanf("%d", &n);
int L = 0, R = 0;
for (int i = 0; i < n; ++i) {
a[i].read();
a[i].x += 1000000;
a[i].y += 1000000;
}
double S = 0;
for (int i = 0; i < n; ++i) S += (a[i] * a[(i + 1) % n]);
if (S > 0) reverse(a, a + n);
for (int i = 0; i < n; ++i) {
if (cmp(a[i], a[L])) L = i;
if (cmp(a[R], a[i])) R = i;
}
int M1 = (int)a[L].x, M2 = (int)a[R].x;
l = L, r = L;
long double a1 = 0;
for (int i = M1; i <= M2; ++i) {
int j = (l + 1) % n, k = (r - 1 + n) % n;
Up(a[l], a[j], i);
Down(a[r], a[k], i);
if (up + 1 < down) assert(false);
c[i] = up - down + 1;
second[i] = up * (up + 1) / 2 - down * (down - 1) / 2;
q[i] = up * (up + 1) * (2 * up + 1) / 6 -
down * (down - 1) * (2 * down - 1) / 6;
a1 += c[i];
}
long double a2 = 0, a3 = 0, a4 = 0, a5 = 0;
for (int i = M1; i <= M2; ++i) {
a2 += q[i] / (a1 - 1), a3 += second[i];
a4 += c[i] * i * i / (a1 - 1), a5 += c[i] * i;
}
long double res =
(a2 + a4) - (a3 / (a1 - 1)) * (a3 / a1) - (a5 / (a1 - 1)) * (a5 / a1);
printf("%.9lf", (double)res);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e6 + 2e5;
const int N = M >> 1;
const int MX = 2e6;
const int D = 1e6;
double L[M], R[M];
int g[M];
struct pnt {
int x, y;
void input() { scanf("%d %d", &x, &y); }
} p[N];
int n;
double ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
p[i].input();
p[i].x += D, p[i].y += D;
}
function<void(int, double)> update = [&](int y, double x) {
L[y] = min(L[y], x);
R[y] = max(R[y], x);
};
for (int step = 0; step < 2; step++) {
for (int i = 0; i <= MX; i++) L[i] = M, R[i] = -1;
for (int i = 1; i <= n; i++) {
update(p[i].y, p[i].x);
int ni = i == n ? 1 : i + 1;
if (p[i].y == p[ni].y) continue;
double d = (p[ni].x - p[i].x) * 1.0 / (p[ni].y - p[i].y);
double cur;
cur = p[i].x;
for (int j = p[i].y + 1; j < p[ni].y; j++) {
cur += d;
update(j, cur);
}
cur = p[ni].x;
for (int j = p[ni].y + 1; j < p[i].y; j++) {
cur += d;
update(j, cur);
}
}
long long tot = 0;
for (int i = 0; i <= MX; i++) {
int lx = L[i] + 0.9999999;
int rx = R[i] + 0.0000001;
g[i] = rx >= lx ? rx - lx + 1 : 0;
tot += g[i];
}
double c = 0, d = 0, dd = 0;
for (int i = 0; i < MX; i++) {
double r = g[i] * 1.0 / (tot - 1);
d = d + dd + r;
dd = dd + r + r;
c = c + d;
ans += 1.0 * g[i + 1] / tot * c;
}
for (int i = 1; i <= n; i++) swap(p[i].x, p[i].y);
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T min(T &a, T &b) {
return a < b ? a : b;
}
template <class T>
inline T max(T &a, T &b) {
return a > b ? a : b;
}
template <class T>
void read(T &x) {
char ch;
while ((ch = getchar()) && !isdigit(ch))
;
x = ch - '0';
while ((ch = getchar()) && isdigit(ch)) x = x * 10 + ch - '0';
}
long long Pow(long long a, long long b, long long Mod) {
long long ans = 1;
a %= Mod;
for (; b; b >>= 1) ans = b & 1 ? (ans * a % Mod) : ans, a = a * a % Mod;
return ans;
}
const int N = 2200000, L = 2000000;
struct lj {
int x, y;
} P[N];
const long double eps = 1e-7;
int Max[N], Min[N], n;
long double ans, cnt;
void add(int X1, int Y1, int X2, int Y2) {
if (X1 > X2) swap(X1, X2), swap(Y1, Y2);
if (X1 == X2) {
Min[X1] = min(Min[X1], min(Y1, Y2)), Max[X1] = max(Max[X1], max(Y1, Y2));
return;
}
long double p = (long double)(Y2 - Y1) / (X2 - X1);
for (long double c = Y1; X1 <= X2; X1++, c += p) {
Min[X1] = min(Min[X1], (int)ceil(c - (eps)));
Max[X1] = max(Max[X1], (int)floor(c + (eps)));
}
}
void work() {
for (int i = 0; i <= L; i++) Min[i] = int(2e9), Max[i] = -int(2e9);
for (int i = 1; i <= n; i++)
add(P[i].x, P[i].y, P[i % n + 1].x, P[i % n + 1].y);
cnt = 0;
long double p0 = 0, p1 = 0, p2 = 0, q0 = 0, q1 = 0, q2 = 0;
for (int i = 0; i <= L; i++)
if (Max[i] != -int(2e9)) {
cnt += Max[i] - Min[i] + 1;
p0 = Max[i] - Min[i] + 1;
p1 = (long double)i * (Max[i] - Min[i] + 1);
p2 = (long double)i * i * (Max[i] - Min[i] + 1);
ans += p2 * q0 + p0 * q2 - 2. * p1 * q1;
q0 += Max[i] - Min[i] + 1;
q1 += (long double)i * (Max[i] - Min[i] + 1);
q2 += (long double)i * i * (Max[i] - Min[i] + 1);
} else
break;
}
int main() {
scanf("%d", &n);
int Minx = int(2e9), Miny = int(2e9);
for (int i = 1; i <= n; i++)
scanf("%d%d", &P[i].x, &P[i].y), Minx = min(Minx, P[i].x),
Miny = min(Miny, P[i].y);
for (int i = 1; i <= n; i++) P[i].x -= Minx, P[i].y -= Miny;
work();
for (int i = 1; i <= n; i++) swap(P[i].x, P[i].y);
work();
printf("%.10lf\n", (double)(ans / cnt / (cnt - 1.)));
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int Read() {
char c;
while (c = getchar(), (c != '-') && (c < '0' || c > '9'))
;
bool neg = (c == '-');
int ret = (neg ? 0 : c - 48);
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + c - 48;
return neg ? -ret : ret;
}
const int MAXN = 100005, MAXM = 2000005;
pair<int, int> a[MAXN];
int N, l[MAXM], r[MAXM];
long double cnt;
void init() {
scanf("%d", &N);
int mx = MAXM, my = MAXM;
for (int i = 1; i <= N; i++)
a[i].first = Read(), a[i].second = Read(), mx = min(mx, a[i].first),
my = min(my, a[i].second);
for (int i = 1; i <= N; i++) a[i].first -= (mx - 1), a[i].second -= (my - 1);
}
long double Solve() {
double rot = 0;
a[N + 1] = a[1];
int mx = 0;
cnt = 0;
for (int i = 1; i <= N; i++)
rot += a[i].first * a[i + 1].second - a[i].second * a[i + 1].first,
mx = max(mx, a[i].first);
if (rot > 0) reverse(a + 1, a + N + 2);
for (int i = 1; i <= N; i++) {
long long x1 = a[i].first, y1 = a[i].second, x2 = a[i + 1].first,
y2 = a[i + 1].second;
if (x1 < x2)
for (int j = x1; j <= x2; j++)
r[j] = (y1 * (x2 - j) + y2 * (j - x1)) / (x2 - x1);
if (x1 > x2)
for (int j = x2; j <= x1; j++)
l[j] = (y2 * (x1 - j) + y1 * (j - x2) - 1) / (x1 - x2);
}
long double s1 = 0, s2 = 0;
for (int i = 0; i <= mx; i++)
cnt += r[i] - l[i], s1 += 1.0 * i * (r[i] - l[i]),
s2 += 1.0 * i * i * (r[i] - l[i]);
return s2 * cnt - s1 * s1;
}
void work() {
long double ans = Solve();
for (int i = 1; i <= N; i++) swap(a[i].first, a[i].second);
printf("%.10f\n", (double)((ans + Solve()) / cnt / (cnt - 1)));
}
int main() {
init();
work();
return 0 - 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x[1000001 << 1], y[1000001 << 1], cx[1000001], cy[1000001];
long long CNT;
long double TWO, ONE;
vector<long double> xx[2000001];
int get(long double v1, long double v2) {
return (int)(floor(v2 + 1e-9) - ceil(v1 - 1e-9)) + 1;
}
void go(int px[], int py[], int n) {
long double two = 0, sum = 0, sec = 0;
int i, j;
long long cnt = 0;
if ((long long)(px[0] - px[1]) * (py[2] - py[1]) -
(long long)(px[2] - px[1]) * (py[0] - py[1]) >
0) {
for (i = 1; i < n - i; i++) {
swap(px[i], px[n - i]);
swap(py[i], py[n - i]);
}
}
for (i = 0; i <= 2000000; i++) xx[i].clear();
for (i = 0; i < n; i++) {
if (px[i] < px[i + 1]) {
for (j = px[i]; j <= px[i + 1]; j++) {
xx[j + 1000001].push_back(py[i] + (py[i + 1] - py[i]) * 1. *
(j - px[i]) /
(px[i + 1] - px[i]));
}
} else if (px[i] > px[i + 1]) {
for (j = px[i + 1]; j <= px[i]; j++) {
xx[j + 1000001].push_back(py[i] + (py[i + 1] - py[i]) * 1. *
(j - px[i]) /
(px[i + 1] - px[i]));
}
} else {
xx[px[i] + 1000001].push_back(py[i]);
xx[px[i] + 1000001].push_back(py[i + 1]);
}
}
for (i = 0; i <= 2000000; i++) {
if (xx[i].size()) {
long long ker = i - 1000001;
sort(xx[i].begin(), xx[i].end());
int now = get(xx[i][0], xx[i].back());
long long nt_cnt = cnt + now;
long double nt_two = two + ((long double)ker * ker * cnt -
(long double)ker * sum * 2 + sec) *
now;
long double nt_sec = sec + (long double)ker * ker * now;
long double nt_sum = sum + (long double)ker * now;
cnt = nt_cnt;
two = nt_two;
sec = nt_sec;
sum = nt_sum;
}
}
CNT = cnt;
TWO += two;
}
int main() {
int i, j, k, n, No, miX = 100000000, miY;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
cx[i] = x[i];
cy[i] = y[i];
x[n + i] = x[i];
y[n + i] = y[i];
if (x[i] < miX || (x[i] == miX && y[i] < miY)) {
miX = x[i];
miY = y[i];
No = i;
}
}
go(x + No, y + No, n);
miX = 100000000;
for (i = 0; i < n; i++) {
x[i] = cy[i];
y[i] = cx[i];
x[n + i] = x[i];
y[n + i] = y[i];
if (x[i] < miX || (x[i] == miX && y[i] < miY)) {
miX = x[i];
miY = y[i];
No = i;
}
}
go(x + No, y + No, n);
printf("%.15lf\n", (double)(TWO * 0.5 / ((long double)CNT * (CNT - 1) / 2)));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:600000000")
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
double const pi = 3.1415926535897932384626433832795;
int const inf = (int)1e9;
long long const inf64 = (long long)4e18;
const string name = "d";
const int NMAX = 101010;
const int XMAX = 2001010;
int n, x[NMAX], y[NMAX];
int l[XMAX], r[XMAX], zn[XMAX];
void update(int x1, int qqqqqqq, int x2, int y2) {
if (x1 == x2) {
l[x1] = min(l[x1], min(qqqqqqq, y2));
r[x1] = max(r[x1], max(qqqqqqq, y2));
return;
}
if (x1 > x2) {
swap(x1, x2);
swap(qqqqqqq, y2);
}
for (int i = x1; i <= x2; ++i) {
int now;
now = qqqqqqq + (double)(i - x1) * (y2 - qqqqqqq) / (x2 - x1) - 1e-7 + 1;
l[i] = min(l[i], now);
now = qqqqqqq + (double)(i - x1) * (y2 - qqqqqqq) / (x2 - x1) + 1e-7;
r[i] = max(r[i], now);
}
}
double solve() {
x[n] = x[0], y[n] = y[0];
for (int i = 0; i < (int)XMAX; i++) l[i] = inf, r[i] = -inf;
for (int i = 0; i < (int)n; i++) update(x[i], y[i], x[i + 1], y[i + 1]);
for (int i = 0; i < (int)XMAX; i++) zn[i] = max(0, r[i] - l[i] + 1);
double ans = 0, now = 0, cnt = 0, dist = 0;
for (int i = 0; i < (int)XMAX; i++) {
ans += zn[i] * now;
cnt += zn[i];
now += 2 * dist + cnt;
dist += cnt;
}
return ans / (cnt * (cnt - 1) / 2);
}
int main() {
cin >> n;
for (int i = 0; i < (int)n; i++) scanf("%d%d", &x[i], &y[i]);
int xmin = 0, ymin = 0;
for (int i = 0; i < (int)n; i++) {
xmin = min(xmin, x[i]);
ymin = min(ymin, y[i]);
}
for (int i = 0; i < (int)n; i++) {
x[i] -= xmin;
y[i] -= ymin;
}
double ans = solve();
for (int i = 0; i < (int)n; i++) swap(x[i], y[i]);
ans += solve();
printf("%.10lf\n", ans / 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 105000;
const int T = 1000000;
const int M = 2005000;
const double mi = 1e-8;
const int inf = 1987654321;
int n;
int cha;
int a[N], b[N];
int minz[M], maxz[M];
int l, r;
int cc[M];
double ans = 0.0;
long long m;
void getData() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
a[i] += T;
b[i] += T;
}
a[n + 1] = a[1];
b[n + 1] = b[1];
}
double fang() {
double res = 0;
int i;
for (i = l; i <= r; i++) {
double now = i - cha;
now *= i - cha;
now *= cc[i];
now *= m;
res += now;
}
return res;
}
double ji() {
double res = 0.0;
int i;
for (i = l; i <= r; i++) {
double now = i - cha;
now *= cc[i];
res += now;
}
res *= res;
return res;
}
void Do(int x[], int y[]) {
memset(minz, 0x3f, sizeof minz);
memset(maxz, 0xc0, sizeof maxz);
l = inf;
r = -inf;
int i, j;
for (i = 1; i <= n; i++) {
int p = x[i];
int q = y[i];
int s = x[i + 1];
int t = y[i + 1];
if (p > s) {
swap(p, s);
swap(q, t);
}
l = min(l, p);
r = max(r, s);
for (j = p; j <= s; j++) {
if (p == s) {
if (q > t) swap(q, t);
minz[j] = min(minz[j], q);
maxz[j] = max(maxz[j], t);
continue;
}
double now = t - q;
now *= j - p;
now /= s - p;
now += q;
int zheng = floor(now + 0.5);
if (now - zheng < mi && zheng - now < mi) {
minz[j] = min(minz[j], zheng);
maxz[j] = max(maxz[j], zheng);
} else {
int qz = floor(now);
minz[j] = min(minz[j], qz + 1);
maxz[j] = max(maxz[j], qz);
}
}
}
for (i = l; i <= r; i++) cc[i] = maxz[i] - minz[i] + 1;
m = 0;
for (i = l; i <= r; i++) m += cc[i];
int aim = (m + 1) / 2;
for (i = l; i <= r; i++) {
if (aim <= cc[i]) break;
aim -= cc[i];
}
cha = i;
ans += fang();
ans -= ji();
}
void print() {
ans /= m;
ans /= (m - 1);
printf("%.8f\n", ans);
}
int main() {
getData();
Do(a, b);
Do(b, a);
print();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxXL = 1000000;
const int MaxN = 100000;
inline long long floor(long long a, long long b) {
if (b < 0) a = -a, b = -b;
if (a > 0) return a / b;
return -((-a + b - 1) / b);
}
inline long long ceil(long long a, long long b) { return -floor(-a, b); }
double calc(int n, int *px, int *py) {
long long area = 0;
for (int i = 0; i < n; i++)
area += (long long)px[i] * py[i + 1] - (long long)py[i] * px[i + 1];
if (area < 0) reverse(px + 1, px + n), reverse(py + 1, py + n);
static int h[MaxXL * 2 + 1];
fill(h, h + MaxXL * 2 + 1, 0);
for (int i = 0; i < n; i++) {
if (px[i] < px[i + 1]) {
for (int x = px[i]; x < px[i + 1]; x++)
h[x + MaxXL] -= py[i] +
ceil((long long)(py[i + 1] - py[i]) * (x - px[i]),
px[i + 1] - px[i]) -
1;
if (px[i + 1] >= px[(i + 2) % n]) h[px[i + 1] + MaxXL] -= py[i + 1] - 1;
} else if (px[i] > px[i + 1]) {
for (int x = px[i]; x > px[i + 1]; x--)
h[x + MaxXL] +=
py[i] + floor((long long)(py[i + 1] - py[i]) * (x - px[i]),
px[i + 1] - px[i]);
if (px[i + 1] <= px[(i + 2) % n]) h[px[i + 1] + MaxXL] += py[i + 1];
}
}
long long cnt = 0;
double sum1 = 0;
double sum2 = 0;
for (int x = -MaxXL; x <= MaxXL; x++) {
cnt += h[x + MaxXL];
sum1 += (double)x * h[x + MaxXL];
sum2 += (double)x * x * h[x + MaxXL];
}
return (sum2 - sum1 * sum1 / cnt) / (cnt - 1);
}
int main() {
int n;
static int px[MaxN + 1], py[MaxN + 1];
cin >> n;
for (int i = 0; i < n; i++) scanf("%d %d", &px[i], &py[i]);
px[n] = px[0], py[n] = py[0];
double res = 0;
res += calc(n, px, py);
res += calc(n, py, px);
printf("%.10f\n", res);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int E = 1000100;
int n, i, j, x[100100], y[100100], Cx[2 * E], Cy[2 * E], Dx[2 * E], Dy[2 * E];
double d, sqri, ddx, ddy, sqx, sqy, smx, smy, cntx, cnty, sum, eps = 1e-9;
double sqr(double x) { return x * x; }
int main() {
memset(Cx, 120, sizeof(Cx));
memset(Cy, 120, sizeof(Cy));
memset(Dx, 140, sizeof(Dx));
memset(Dy, 140, sizeof(Dy));
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
x[i] += E;
y[i] += E;
}
x[n] = x[0];
y[n] = y[0];
for (i = 0; i < n; i++) {
double A = y[i + 1] - y[i];
double B = x[i] - x[i + 1];
double C = -A * x[i] - B * y[i];
int cx = min(x[i], x[i + 1]), dx = max(x[i], x[i + 1]);
int cy = min(y[i], y[i + 1]), dy = max(y[i], y[i + 1]);
if (x[i] == x[i + 1]) {
Cy[x[i]] = min(Cy[x[i]], cy);
Dy[x[i]] = max(Dy[x[i]], dy);
} else
for (j = cx; j <= dx; j++) {
d = (-A * j - C) / B;
Cy[j] = min(Cy[j], int(d - eps) + 1);
Dy[j] = max(Dy[j], int(d + eps));
}
if (y[i] == y[i + 1]) {
Cx[y[i]] = min(Cx[y[i]], cx);
Dx[y[i]] = max(Dx[y[i]], dx);
} else
for (j = cy; j <= dy; j++) {
d = (-B * j - C) / A;
Cx[j] = min(Cx[j], int(d - eps) + 1);
Dx[j] = max(Dx[j], int(d + eps));
}
}
for (i = 0; i < 2 * E; i++) {
sqri = sqr(i);
if (Dx[i] >= Cx[i]) {
ddx = Dx[i] - Cx[i] + 1;
sum += ddx * (sqx - 2 * smx * i + cntx * sqri);
sqx += sqri * ddx;
smx += i * ddx;
cntx += ddx;
}
if (Dy[i] >= Cy[i]) {
ddy = Dy[i] - Cy[i] + 1;
sum += ddy * (sqy - 2 * smy * i + cnty * sqri);
sqy += sqri * ddy;
smy += i * ddy;
cnty += ddy;
}
}
printf("%.10lf\n", sum / cntx / (cntx - 1.));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T nextInt() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * p;
}
const int maxN = (int)1e5 + 10;
const int maxK = (int)2e6 + 10;
const int OFFSET = (int)1e6 + 1;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const long double LLINF = (long double)1e15;
struct pt {
long double x, y;
};
int n;
pt poly[maxN];
vector<long double> byX[maxK];
void find(pt a, pt b, long double &A, long double &B, long double &C) {
A = a.y - b.y;
B = b.x - a.x;
C = -A * a.x - B * a.y;
}
void process(pt a, pt b) {
if (a.x == b.x) {
byX[(int)a.x + OFFSET].push_back(a.y);
byX[(int)b.x + OFFSET].push_back(b.y);
return;
}
long double A, B, C;
find(a, b, A, B, C);
if (a.x > b.x) swap(a, b);
for (int x = a.x; x <= b.x; ++x) {
long double y = -(A * x + C) / 1.0 / B;
byX[x + OFFSET].push_back(y);
}
}
long double ALL = 0;
long double solve() {
for (int i = 0; i < maxK; ++i) {
byX[i].clear();
}
for (int i = 0; i < n; ++i) {
process(poly[i], poly[i + 1]);
}
long double ret = 0LL;
long double sums = 0LL;
long double sumx = 0LL;
long double pts = 0LL;
for (int i = 0; i < maxK; ++i) {
if (byX[i].empty()) continue;
sort(byX[i].begin(), byX[i].end());
long double x = i - OFFSET;
long double lo = ceill(byX[i][0]);
long double hi = floorl(byX[i].back());
if (lo > hi) continue;
int len = (int)hi - (int)lo + 1;
ret += (x * 1LL * x * pts + sums - 2LL * x * sumx) * len;
sums += x * 1LL * x * len;
sumx += x * len;
pts += len;
}
ALL = pts;
return ret;
}
int main() {
n = nextInt<int>();
for (int i = 0; i < n; ++i) {
poly[i].x = nextInt<int>();
poly[i].y = nextInt<int>();
}
poly[n] = poly[0];
long double res = 0LL;
res += solve();
for (int i = 0; i <= n; ++i) {
swap(poly[i].x, poly[i].y);
}
res += solve();
long double answer = res / 1.0 / ALL;
answer /= ALL - 1;
cout.precision(20);
cout << answer << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long double solve(vector<long long> x, vector<long long> y, long long n) {
long long area = 0;
for (long long i = 0; i < n; i++) {
long long ax = x[i], bx = x[(i + 1) % n];
long long ay = y[i], by = y[(i + 1) % n];
area += ax * by - ay * bx;
}
if (area > 0) {
reverse(x.begin(), x.end());
reverse(y.begin(), y.end());
}
vector<long double> count(2e6 + 10, 0);
long long maxx = -1e9;
for (long long i = 0; i < n; i++) {
long long ax = x[i], bx = x[(i + 1) % n];
long long ay = y[i], by = y[(i + 1) % n];
for (long long j = ax; j < bx; j++) {
count[j] += (ay * (bx - ax) + (by - ay) * (j - ax)) / (bx - ax);
}
for (long long j = bx; j < ax; j++) {
count[j] -= (by * (ax - bx) + (ay - by) * (j - bx) - 1) / (ax - bx);
}
if (ax == bx && by < ay) {
count[ax] += ay - by;
}
maxx = max(maxx, ax);
}
count[maxx]++;
long double sum = 0, sum2 = 0, tot = 0;
for (long long i = 0; i < count.size(); i++) {
tot += count[i];
sum += count[i] * i;
}
assert(tot > 1);
sum /= tot;
for (long long i = 0; i < count.size(); i++) {
sum2 += count[i] * (i - sum) * (i - sum);
}
return 2 * sum2 / (tot - 1);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> x(n), y(n);
for (long long i = 0; i < n; i++) {
cin >> x[i] >> y[i];
x[i] += 1e6 + 1;
y[i] += 1e6 + 1;
}
long double ans = 0;
ans += solve(x, y, n);
ans += solve(y, x, n);
cout << fixed << setprecision(10) << ans / 2;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
double x[100000], y[100000];
double Intersection(int i, int j, int level) {
return (double)(level - y[i]) / (y[j] - y[i]) * (x[j] - x[i]) + x[i];
}
void Scan(int n, double& sum, double& square_sum, long long& ct) {
int start = 0;
for (int i = 1; i < n; ++i) {
if (y[i] > y[start]) {
start = i;
}
}
int a = start, b = start;
while (y[(b + 1) % n] == y[b]) {
b = (b + 1) % n;
}
b = (b + 1) % n;
while (y[(a - 1 + n) % n] == y[a]) {
a = (a - 1 + n) % n;
}
a = (a - 1 + n) % n;
int level = y[start];
while (true) {
double l = Intersection(a, (a + 1) % n, level);
double r = Intersection(b, (b - 1 + n) % n, level);
if (l > r) swap(l, r);
l = ceil(l);
r = floor(r);
ct += r - l + 1;
sum += (l + r) * (r - l + 1) / 2;
--l;
square_sum += r * (r + 1) * (2 * r + 1) / 6 - l * (l + 1) * (2 * l + 1) / 6;
if (y[a] == level) {
a = (a - 1 + n) % n;
if (y[a] >= level) break;
}
if (y[b] == level) {
b = (b + 1) % n;
}
--level;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%lf%lf", x + i, y + i);
if (i > 0 && x[i] == x[i - 1] && y[i] == y[i - 1]) {
--i, --n;
}
}
if (x[n - 1] == x[0] && y[n - 1] == y[0]) {
--n;
}
double sum = 0;
double square_sum = 0;
long long ct = 0;
Scan(n, sum, square_sum, ct);
double answer = ct * square_sum - sum * sum;
for (int i = 0; i < n; ++i) {
swap(x[i], y[i]);
}
sum = 0;
square_sum = 0;
ct = 0;
Scan(n, sum, square_sum, ct);
answer += ct * square_sum - sum * sum;
printf("%.10f\n", answer / ct / (ct - 1));
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, X[100006], Y[100006];
vector<vector<pair<int, int> > > H;
void solve() {
int i, j, k, l, r, x, y;
string s;
H.resize(2000005);
cin >> N;
for (i = 0; i < N; i++) cin >> X[i] >> Y[i], X[i] += 1000000, Y[i] += 1000000;
double ret = 0;
double T;
for (k = 0; k < 2; k++) {
T = 0;
for (x = 0; x < 2000001; x++) H[x].clear();
for (i = 0; i < N; i++) {
H[X[i]].push_back(make_pair(Y[i], Y[i]));
if (X[i] != X[(i + 1) % N]) {
int dx = (X[i] < X[(i + 1) % N]) ? 1 : -1;
for (x = X[i] + dx; x != X[(i + 1) % N]; x += dx) {
signed long long dy = 1LL * (x - X[i]) * (Y[(i + 1) % N] - Y[i]);
signed long long y2 = Y[i] + dy / (X[(i + 1) % N] - X[i]);
if ((dy >= 0) ^ (X[(i + 1) % N] < X[i]))
H[x].push_back(
make_pair(y2, y2 + ((dy % (X[(i + 1) % N] - X[i]) != 0))));
else
H[x].push_back(
make_pair(y2 - (dy % (X[(i + 1) % N] - X[i]) != 0), y2));
}
}
}
double S1 = 0, S2 = 0;
for (x = 0; x < 2000001; x++)
if (H[x].size()) {
int mf = H[x][0].first, ms = H[x][0].second;
for (i = 0; i < H[x].size(); i++)
mf = max(mf, H[x][i].first), ms = min(ms, H[x][i].second);
int h = mf - ms + 1;
if (h <= 0) continue;
ret += h * (T * x * x - 2LL * x * S1 + S2);
T += h;
S1 += 1LL * h * x;
S2 += 1LL * h * x * x;
}
for (i = 0; i < N; i++) swap(X[i], Y[i]);
}
(void)printf("%.12lf\n", ret / (T - 1.0) / T);
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false);
for (i = 0; i < argc - 1; i++) s += argv[i + 1], s += '\n';
for (i = 0; i < s.size(); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 10, MAXM = (int)2e6 + 10, D = (int)1e6 + 5;
int n, first[MAXN], second[MAXN], u[MAXM], d[MAXM];
long long tot;
long double Tohka;
void Upd(int &u, int &d, int second, int t) {
u = max(u, second);
d = min(d, second + t);
}
void Work(int &u, int &d, int xa, int ya, int xb, int yb, int first) {
int Y = (int)((long double)ya +
((long double)(yb - ya) / (xb - xa) * (first - xa)));
if ((long long)(yb - ya) * (first - xa) % (xb - xa) == 0)
Upd(u, d, Y, 0);
else
Upd(u, d, Y, 1);
}
void Calc() {
tot = 0;
int l = MAXM, r = 0;
for (int i = 0; i < MAXM; ++i) d[i] = MAXM, u[i] = 0;
for (int i = 1; i <= n; ++i) {
int xa = first[i], xb = first[((i + 1) > n) ? 1 : (i + 1)], ya = second[i],
yb = second[((i + 1) > n) ? 1 : (i + 1)];
if (xa > xb) swap(xa, xb), swap(ya, yb);
Upd(u[first[i]], d[first[i]], second[i], 0);
l = min(l, first[i]);
r = max(r, first[i]);
if (xa != xb)
for (int j = xa; j <= xb; ++j) Work(u[j], d[j], xa, ya, xb, yb, j);
}
long double s = 0, a = 0, b = 0;
for (int i = l; i <= r; ++i) {
int c = u[i] - d[i] + 1;
tot += c;
s += a * i + b;
a += (long double)c * 2;
b += (long double)-c * 2 * (i + 1) + c;
Tohka += s * c;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d%d", &first[i], &second[i]), first[i] += D, second[i] += D;
Calc();
for (int i = 1; i <= n; ++i) swap(first[i], second[i]);
Calc();
Tohka /= (long double)tot * (tot - 1);
cout << setprecision(10);
cout << fixed << Tohka << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long x, y;
};
int N;
point P[100010];
long long area(point &P, point &Q) { return P.x * Q.y - P.y * Q.x; }
bool smaller(point &P, point &Q) {
if (P.x < Q.x) return true;
if (P.x == Q.x && P.y < Q.y) return true;
return false;
}
long long low[2000010], high[2000010];
void lower(point P, point Q) {
if (P.x == Q.x) return;
for (int i = P.x; i <= Q.x; i++) {
double y = P.y + (double)(Q.y - P.y) / (Q.x - P.x) * (i - P.x);
low[i] = max(low[i], (long long)(y - 1.0E-7) + 1);
}
}
void upper(point P, point Q) {
if (P.x == Q.x) return;
for (int i = P.x; i <= Q.x; i++) {
double y = P.y + (double)(Q.y - P.y) / (Q.x - P.x) * (i - P.x);
high[i] = min(high[i], (long long)(y + 1.0E-7));
}
}
double func(void) {
int i;
long long s = 0;
for ((i) = 0; (i) < (int)(N); (i)++) s += area(P[i], P[(i + 1) % N]);
if (s < 0) reverse(P, P + N);
int L = 0, R = 0;
for ((i) = 0; (i) < (int)(N); (i)++) {
if (smaller(P[i], P[L])) L = i;
if (smaller(P[R], P[i])) R = i;
}
int X1 = P[L].x;
int X2 = P[R].x;
for (i = X1; i <= X2; i++) low[i] = -(1 << 29);
for (i = X1; i <= X2; i++) high[i] = (1 << 29);
for (i = 0;; i++) {
int a = (L + i) % N, b = (L + i + 1) % N;
lower(P[a], P[b]);
if (b == R) break;
}
for (i = 0;; i++) {
int a = (R + i + 1) % N, b = (R + i) % N;
upper(P[a], P[b]);
if (a == L) break;
}
double cnt = 0.0;
double xsum = 0.0;
double x2sum = 0.0;
for (i = X1; i <= X2; i++) {
double tmp = high[i] - low[i] + 1;
cnt += tmp;
xsum += tmp * (double)i;
x2sum += tmp * (double)i * (double)i;
}
double ans = 2.0 * cnt * x2sum - 2.0 * xsum * xsum;
return ans / cnt / (cnt - 1.0);
}
int main(void) {
int i;
cin >> N;
for ((i) = 0; (i) < (int)(N); (i)++) {
int x, y;
scanf("%d%d", &x, &y);
P[i].x = x + 1000000;
P[i].y = y + 1000000;
}
double ans1 = func();
for ((i) = 0; (i) < (int)(N); (i)++) swap(P[i].x, P[i].y);
double ans2 = func();
printf("%.9f\n", (ans1 + ans2) / 2.0);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inv = numeric_limits<int>::max();
const int minv = numeric_limits<int>::min();
const int max_n = 100010;
const int clim = 1000010;
int n;
pair<int, int> v[max_n];
double res = 0.0;
double c[2 * clim + 1][2];
int csz[2 * clim + 1];
int miny, maxy;
void markoff(int i) {
int j = (i + 1) % n;
int x1 = v[i].first, y1 = v[i].second, x2 = v[j].first, y2 = v[j].second;
if (y1 == y2)
c[y1 - miny][csz[y1 - miny]++] = x1;
else {
double dx = ((double(x2 - x1)) / (abs((double(y2 - y1)))));
double x = x1;
for (int y = y1; y != y2; y += ((y2 - y1) / (abs(y2 - y1)))) {
c[y - miny][csz[y - miny]++] = x;
x += dx;
}
}
}
int rddn(double d) {
if (abs(d - floor(d)) < (1.0e-12)) return (int(floor(d)));
if (abs(d - ceil(d)) < (1.0e-12)) return (int(ceil(d)));
return (int(floor(d)));
}
int rdup(double d) {
if (abs(d - floor(d)) < (1.0e-12)) return (int(floor(d)));
if (abs(d - ceil(d)) < (1.0e-12)) return (int(ceil(d)));
return (int(ceil(d)));
}
double a[2 * clim + 1];
void finda(int y) {
if (csz[y] == 1) {
a[y] = 1;
return;
}
double x1 = c[y][0], x2 = c[y][1];
if (x1 > x2) swap(x1, x2);
int rx1 = rdup(x1), rx2 = rddn(x2);
a[y] = (double(rx2 - rx1 + 1));
}
double sa[2 * clim + 2];
void process() {
miny = inv;
maxy = minv;
for (int i = 0; i < n; ++i) {
miny = min(miny, v[i].second);
maxy = max(maxy, v[i].second);
}
fill(csz, csz + maxy - miny + 1, 0);
for (int i = 0; i < n; ++i) markoff(i);
for (int y = 0; y <= maxy - miny; ++y) finda(y);
sa[maxy - miny + 1] = 0.0;
for (int y = maxy - miny; y >= 0; --y) sa[y] = sa[y + 1] + a[y];
double Qa = 0.0;
double dQa = a[maxy - miny];
for (int y = maxy - miny - 1; y >= 0; --y) {
Qa += dQa;
res += a[y] * Qa;
dQa += (a[y] + 2.0 * sa[y + 1]);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &v[i].first);
scanf("%d", &v[i].second);
}
process();
for (int i = 0; i < n; ++i) swap(v[i].first, v[i].second);
process();
res /= (sa[0] * (sa[0] - 1.0) / 2.0);
res /= 2.0;
printf("%.12f", res);
return 0;
}
| 10 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.