solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
struct edge {
int to, next;
} e[N * 2];
int head[N], tot;
int vis[N], q[N], V;
int deg[N], n, sz;
double ans;
void add(int x, int y) {
e[++tot] = (edge){y, head[x]};
head[x] = tot;
}
void dfs(int x, int A, int B) {
deg[x] == 2 ? B++ : A++;
vis[x] = V;
if (B == sz)
ans += 1.0 / (A + 2);
else if (B <= 2)
ans += 1.0 / (A + B);
else
ans += 1.0 / (A + B) + 1.0 / (A + sz - B + 2) - 1.0 / (A + sz);
for (int i = head[x]; i; i = e[i].next)
if (vis[e[i].to] != V) dfs(e[i].to, A, B);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
++x;
++y;
deg[x]++;
deg[y]++;
add(x, y);
add(y, x);
}
int t = 0;
for (int i = 1; i <= n; i++)
if (deg[i] == 1) q[++t] = i;
for (; t;) {
int x = q[t--];
for (int i = head[x]; i; i = e[i].next)
if ((--deg[e[i].to]) == 1) q[++t] = e[i].to;
}
for (int i = 1; i <= n; i++)
if (deg[i] == 2) ++sz;
for (V = 1; V <= n; V++) dfs(V, 0, 0);
printf("%.10lf\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
char ch;
inline void read(int &x) {
x = 0;
ch = getchar();
while (ch <= 32) ch = getchar();
while (ch > 32) {
x = x * 10 + ch - 48;
ch = getchar();
};
};
int n;
struct edge {
edge *next;
int y;
};
edge *se[3005], e[3005 * 2], *etot = e;
inline void addedge(int x, int y) {
*++etot = (edge){se[x], y};
se[x] = etot;
};
int fa[3005];
inline int getfa(int x) { return fa[x] ? fa[x] = getfa(fa[x]) : x; };
inline bool merge(int x, int y) {
x = getfa(x);
y = getfa(y);
if (x == y) return false;
fa[x] = y;
return true;
};
int _y, _top, cyclen;
int _stack[3005];
bool isoncyc[3005];
inline void dfs(int x, int last) {
if (x == _y) {
cyclen = _top;
while (_top) isoncyc[_stack[_top--]] = true;
return;
};
edge *te = se[x];
while (te) {
int ty = te->y;
if (ty ^ last) {
_stack[++_top] = ty;
dfs(ty, x);
if (cyclen) return;
--_top;
};
te = te->next;
};
};
inline void findcyc(int x, int y) {
_y = y;
_top = 1;
_stack[1] = x;
dfs(x, 0);
};
bool v[3005];
int tot;
int A, B;
double ans;
inline void dfs(int x) {
v[x] = true;
++tot;
A += isoncyc[x];
if (A <= 1) {
ans += 1.0 / tot;
} else {
tot += cyclen - A;
ans +=
0.5 * (1.0 / tot + (A - 2.0) / ((tot + 0.0) * (tot - A + 2.0)) +
(cyclen - A + 0.0) / ((tot + 0.0) * (tot - cyclen + A + 0.0)));
tot -= cyclen - A;
};
edge *te = se[x];
while (te) {
int ty = te->y;
if (!v[ty]) {
dfs(ty);
};
te = te->next;
};
v[x] = false;
--tot;
A -= isoncyc[x];
};
inline void solve() {
int i;
for (i = 1; i <= n; i++) {
dfs(i);
};
};
int main() {
read(n);
int i;
for (i = 1; i <= n; i++) {
int x, y;
read(x);
read(y);
++x;
++y;
if (!merge(x, y)) {
findcyc(x, y);
};
addedge(x, y);
addedge(y, x);
};
solve();
printf("%.10lf\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3010;
int n, inR[MAXN], dep[MAXN], jmp[13][MAXN];
int top, stk[MAXN], ins[MAXN], bl[MAXN], rt, ringo[MAXN];
vector<int> T[MAXN], Ring;
void dfs(int x, int fa) {
ins[stk[++top] = x] = 1;
for (int v : T[x])
if (v != fa) {
if (ins[v]) throw v;
dfs(v, x);
}
ins[stk[top--]] = 0;
}
void dfst(int x, int fa) {
bl[x] = rt;
dep[x] = dep[fa] + 1;
jmp[0][x] = fa;
for (int v : T[x])
if (v != fa && !inR[v]) dfst(v, x);
}
int dis(int x, int y) {
assert(bl[x] == bl[y]);
int _x = x, _y = y;
if (dep[x] < dep[y]) swap(x, y);
for (int j = 12; ~j; j--)
if (dep[jmp[j][x]] >= dep[y]) x = jmp[j][x];
if (x == y) return dep[_x] + dep[_y] - 2 * dep[x] + 1;
for (int j = 12; ~j; j--)
if (jmp[j][x] != jmp[j][y]) x = jmp[j][x], y = jmp[j][y];
return dep[_x] + dep[_y] - 2 * (dep[x] - 1) + 1;
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i <= n; i++)
scanf("%d%d", &u, &v), ++u, ++v, T[u].push_back(v), T[v].push_back(u);
try {
dfs(1, 0);
} catch (int t) {
for (int i = 1, f = 0; i <= top; i++) {
f |= stk[i] == t;
if (f)
ringo[stk[i]] = Ring.size(), Ring.push_back(stk[i]), inR[stk[i]] = 1;
}
}
for (int p : Ring) rt = p, dfst(p, 0);
for (int j = 1; j <= 12; j++)
for (int i = 1; i <= n; i++) jmp[j][i] = jmp[j - 1][jmp[j - 1][i]];
double Ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (bl[i] == bl[j])
Ans += 1.0 / dis(i, j);
else {
int L = ringo[bl[i]], R = ringo[bl[j]];
if (L > R) swap(L, R);
int x = dep[i] + dep[j], y = R - L - 1, z = Ring.size() - (R - L + 1);
Ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
}
printf("%.15lf\n", Ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
const int MAXN = 3000;
struct edge {
int to;
edge *nxt;
} edges[2 * MAXN + 5], *adj[MAXN + 5], *ecnt = edges;
void addedge(int u, int v) {
edge *p = (++ecnt);
p->to = v, p->nxt = adj[u], adj[u] = p;
p = (++ecnt);
p->to = u, p->nxt = adj[v], adj[v] = p;
}
bool vis[MAXN + 5], tag[MAXN + 5];
int a[MAXN + 5], cnt, siz;
void dfs1(int x, int f) {
vis[a[++cnt] = x] = true;
for (edge *p = adj[x]; p; p = p->nxt) {
if (p->to == f) continue;
if (vis[p->to]) {
siz = 0;
for (int j = cnt;; j--) {
tag[a[j]] = true, siz++;
if (a[j] == p->to) break;
}
} else
dfs1(p->to, x);
if (siz) break;
}
a[cnt--] = 0, vis[x] = false;
}
double ans;
double get(int s, int d) {
if (s >= 2) {
int p = s - 2, q = siz - s, r = d - s + 2;
return 1.0 / (r + p) + 1.0 / (r + q) - 1.0 / (r + p + q);
} else
return 1.0 / d;
}
void dfs2(int x, int s, int d) {
vis[x] = true, d++;
if (tag[x]) s++;
ans += get(s, d);
for (edge *p = adj[x]; p; p = p->nxt) {
if (vis[p->to]) continue;
dfs2(p->to, s, d);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d%d", &a, &b);
addedge(a + 1, b + 1);
}
dfs1(1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) vis[j] = false;
dfs2(i, 0, 0);
}
printf("%.9f\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 100005;
inline int read() {
int res, ok = 1;
char ch;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') ok = -1;
res = ch - '0';
for (ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
res = res * 10 + ch - '0';
return res * ok;
}
int tot, last[3005], n, pre[3005], c[3005], len, o[3005], dis[3005], b[3005],
cnt, cur;
bool vis[3005];
double ans;
struct edge {
int u, v, last;
} e[6005];
inline void link(int u, int v) {
tot++;
e[tot].u = u;
e[tot].v = v;
e[tot].last = last[u];
last[u] = tot;
}
inline bool dfs(int u) {
vis[u] = true;
for (int i = last[u]; i; i = e[i].last) {
int v = e[i].v;
if (v != pre[u]) {
if (!vis[v]) {
pre[v] = u;
if (dfs(v)) return true;
} else {
while (1) {
len++;
c[len] = u;
o[u] = len;
if (u == v) break;
u = pre[u];
}
return true;
}
}
}
return false;
}
inline void dfs1(int u, int fa = -1) {
b[u] = cnt;
for (int i = last[u]; i; i = e[i].last) {
int v = e[i].v;
if (v != fa && !o[v]) {
dis[v] = dis[u] + 1;
dfs1(v, u);
}
}
}
inline void dfs2(int u, int fa, int d) {
ans += 1.0 / d;
for (int i = last[u]; i; i = e[i].last) {
int v = e[i].v;
if (e[i].v != fa && b[v] == cur) dfs2(v, u, d + 1);
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int u, v;
u = read();
v = read();
u++;
v++;
link(u, v);
link(v, u);
}
dfs(1);
for (int i = 1; i <= len; i++) {
cnt++;
dfs1(c[i]);
}
for (int i = 1; i <= n; i++) {
cur = b[i];
dfs2(i, -1, 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (b[i] != b[j]) {
int now = dis[i] + dis[j] + len, x, y;
x = abs(b[i] - b[j]) - 1;
y = len - 2 - x;
ans += 1.0 / now * (1 + x * 1.0 / (now - x) + y * 1.0 / (now - y));
}
printf("%.10lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
const int maxn = 3005;
const int maxm = 6005;
const int inf = 999999999;
struct edge {
int to, next;
};
int n;
edge e[maxm];
int head[maxn], tot;
int stn[maxn], stk[maxn], top = 1;
int cir[maxn], circ;
int cirr[maxn];
bool vis[maxn];
int dis[maxn][maxn];
bool vis2[maxn][maxn];
void dfs2(int u, int p) {
vis[u] = true;
for (int t = head[u]; t; t = e[t].next) {
int v = e[t].to;
if (v == p || vis[v]) continue;
cirr[v] = cirr[u];
dfs2(v, u);
}
}
void dfs3(int u, int p, int r) {
vis2[r][u] = true;
for (int t = head[u]; t; t = e[t].next) {
int v = e[t].to;
if (v == p || vis2[r][v]) continue;
dis[r][v] = dis[r][u] + 1;
dfs3(v, u, r);
}
}
bool dfs1(int u, int p) {
stk[top] = u;
stn[u] = top++;
for (int t = head[u]; t; t = e[t].next) {
int v = e[t].to;
if (v == p) continue;
if (stn[v]) {
for (int i = stn[v]; i < top; i++) vis[cir[circ++] = stk[i]] = true;
return true;
}
if (dfs1(v, u)) return true;
}
top--;
return false;
}
void add_edge(int from, int to) {
e[++tot] = (edge){to, head[from]};
head[from] = tot;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
x++, y++;
add_edge(x, y);
add_edge(y, x);
}
dfs1(1, 0);
for (int i = 0; i < circ; i++) cirr[cir[i]] = cir[i], dfs2(cir[i], 0);
for (int i = 1; i <= n; i++) dis[i][i] = 0, dfs3(i, 0, i);
double ans = 0.0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (cirr[i] == cirr[j])
ans += 1.0 / (dis[i][j] + 1);
else
ans += 1.0 / (dis[i][j] + 1) +
1.0 / (dis[i][j] + circ - dis[cirr[i]][cirr[j]] * 2 + 1) -
1.0 / (dis[i][j] + circ - dis[cirr[i]][cirr[j]]);
}
printf("%0.8lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
vector<int> e[N];
double ans = 0;
int n, h, t, rt, tot, d[N], vis[N], q[N];
void dfs(int u, int a, int b) {
if (d[u] == 2)
++b;
else
++a;
vis[u] = rt;
if (b == tot)
ans += 1.0 / (a + 2);
else if (b <= 2)
ans += 1.0 / (a + b);
else
ans += 1.0 / (a + b) + 1.0 / (a + tot - b + 2) - 1.0 / (a + tot);
for (auto v : e[u])
if (vis[v] ^ rt) dfs(v, a, b);
}
int main() {
scanf("%d", &n), h = 1;
for (int i = 1, x, y; i <= n; i++)
scanf("%d%d", &x, &y), ++x, ++y, e[x].push_back(y), e[y].push_back(x),
++d[x], ++d[y];
for (int i = 1; i <= n; i++)
if (d[i] == 1) q[++t] = i;
for (int x; h <= t;) {
x = q[h++];
for (auto v : e[x]) {
--d[v];
if (d[v] == 1) q[++t] = v;
}
}
for (int i = 1; i <= n; i++)
if (d[i] == 2) ++tot;
for (int i = 1; i <= n; i++) rt = i, dfs(rt, 0, 0);
printf("%0.10lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005, mod = 1e9 + 7;
inline int read() {
int s = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return s;
}
inline long long qpow(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) res = res * a % mod;
return res;
}
inline void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline void dec(int &x, int y) {
x -= y;
if (x < 0) x += mod;
}
int n;
vector<int> G[N], cir;
int dep[N];
int inv[N], fa[N], tag[N], col[N];
int vis[N], f[N][12];
bool flag = 0;
void init(int n) {
for (int i = 1; i <= n; i++) inv[i] = qpow(i, mod - 2);
}
inline void find_cir(int u, int f) {
if (flag) return;
fa[u] = f;
vis[u] = 1;
for (int v : G[u]) {
if (v == f) continue;
if (flag) return;
if (vis[v]) {
while (u != v) cir.push_back(u), u = fa[u];
cir.push_back(v);
flag = 1;
return;
} else
find_cir(v, u);
}
}
void dfs(int u, int fa, int c) {
f[u][0] = fa;
for (int i = 1; i <= 11; i++) f[u][i] = f[f[u][i - 1]][i - 1];
col[u] = c;
dep[u] = dep[fa] + 1;
for (int v : G[u]) {
if (v == fa || tag[v]) continue;
dfs(v, u, c);
}
}
inline int LCA(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 11; i >= 0; i--)
if ((dep[u] - dep[v]) >> i & 1) u = f[u][i];
if (u == v) return u;
for (int i = 11; i >= 0; i--)
if (f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];
return f[u][0];
}
inline int dis(int u, int v) {
return dep[u] + dep[v] - 2 * dep[LCA(u, v)] + 1;
}
int main() {
init(3000);
n = read();
for (int i = 1; i <= n; i++) {
int u = read(), v = read();
u++, v++;
G[u].push_back(v);
G[v].push_back(u);
}
find_cir(1, 0);
for (int u : cir) tag[u] = 1;
for (int i = 0; i < (int)cir.size(); i++) dfs(cir[i], 0, i);
double ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (col[i] == col[j])
ans += 1.0 / dis(i, j);
else {
int x = dep[i] + dep[j], l = abs(col[i] - col[j]) - 1,
r = (int)cir.size() - l - 2;
ans += 1.0 / (x + l) + 1.0 / (x + r) - 1.0 / (x + l + r);
}
}
printf("%.10lf", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
int To[MAXN * 2], Next[MAXN * 2], Final[MAXN], tot;
int Circle[MAXN], Deep[MAXN], Fa[MAXN][MAXN], Lst[MAXN], Top[MAXN], P[MAXN], N,
Up, Down;
void Link(int u, int v) { To[++tot] = v, Next[tot] = Final[u], Final[u] = tot; }
int Get(int a) { return Top[a] == a ? a : Top[a] = Get(Top[a]); }
void Dfs(int Now, int Pre) {
Deep[Now] = Deep[Pre] + 1;
Top[Now] = Now;
for (int i = Final[Now]; i; i = Next[i])
if (To[i] != Pre) {
if (Deep[To[i]] > Deep[Now]) continue;
if (Deep[To[i]]) {
Up = To[i], Down = Now;
continue;
} else
Lst[To[i]] = Now, Dfs(To[i], Now), Top[To[i]] = Now;
}
for (int i = 1; i <= N; i++)
if (Top[i]) {
Fa[Now][i] = Fa[i][Now] = Get(i);
}
}
void Mark(int Now, int Cir) {
if (!Circle[Now]) Circle[Now] = Cir;
for (int i = Final[Now]; i; i = Next[i])
if (!Circle[To[i]]) Mark(To[i], Circle[Now]);
}
int Dis(int u, int v) { return Deep[u] + Deep[v] - 2 * Deep[Fa[u][v]] + 1; }
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
int u, v;
scanf("%d%d", &u, &v);
u++, v++;
Link(u, v), Link(v, u);
}
Dfs(1, 0);
int cnt = 0;
for (int cur = Down;; cur = Lst[cur]) {
Circle[cur] = cur;
P[++cnt] = cur;
if (cur == Up) break;
}
for (; cnt; cnt--) Mark(P[cnt], P[cnt]);
double Ans = 0;
for (int x = 1; x <= N; x++)
for (int y = 1; y <= N; y++) {
if (x == y)
Ans = Ans + 1;
else {
int i = x, j = y;
if (Circle[i] == Circle[j])
Ans += 1.0 / Dis(i, j);
else {
int X = Dis(Circle[j], j) + Dis(Circle[i], i);
if (Deep[Circle[j]] < Deep[Circle[i]]) swap(i, j);
int Y = Dis(Circle[i], Circle[j]) - 2,
Z = Dis(Circle[j], Down) + Dis(Up, Circle[i]) - 2;
Ans += 1.0 / (X + Y) + 1.0 / (X + Z) - 1.0 / (X + Y + Z);
}
}
}
printf("%.11f\n", Ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 3500;
int N;
struct Edge {
int y, nx;
} E[MX << 1];
int H[MX], ec;
void Add(int x, int y) { E[++ec].y = y, E[ec].nx = H[x], H[x] = ec; }
int B[MX], dfn[MX], low[MX], dc;
int Cr[MX], Ic[MX], cc, stk[MX], tp;
void Tarjan(int x, int f) {
B[x] = 1, dfn[x] = low[x] = ++dc, stk[++tp] = x;
for (int i = H[x]; i; i = E[i].nx) {
if (B[E[i].y] == 0)
Tarjan(E[i].y, x), low[x] = min(low[x], low[E[i].y]);
else if (E[i].y != f)
low[x] = min(low[x], dfn[E[i].y]);
}
if (dfn[x] == low[x]) {
if (stk[tp] != x) {
int z = 0;
while (z != x) z = stk[tp--], Cr[++cc] = z, Ic[z] = 1;
} else
tp--;
}
}
int C[MX], Ds[MX][MX];
void dfs1(int x, int f, int c) {
C[x] = c;
for (int i = H[x]; i; i = E[i].nx)
if (E[i].y != f && !Ic[E[i].y]) dfs1(E[i].y, x, c);
}
void dfs2(int x, int f, int rt, int d) {
Ds[rt][x] = d;
for (int i = H[x]; i; i = E[i].nx)
if (E[i].y != f && C[x] == C[E[i].y]) dfs2(E[i].y, x, rt, d + 1);
}
double Calc(int x, int y) {
if (C[x] == C[y]) return 1.0 / Ds[x][y];
int rx = Cr[C[x]], ry = Cr[C[y]];
int a = Ds[x][rx] + Ds[y][ry] + (C[x] - C[y] + cc) % cc - 1;
int b = Ds[x][rx] + Ds[y][ry] + (C[y] - C[x] + cc) % cc - 1;
int c = Ds[x][rx] + Ds[y][ry] + cc - 2;
return 1.0 / a + 1.0 / b - 1.0 / c;
}
int main() {
scanf("%d", &N);
for (int i = (1); i <= (N); ++i) {
int x, y;
scanf("%d%d", &x, &y), ++x, ++y;
Add(x, y), Add(y, x);
}
Tarjan(1, 0);
for (int i = (1); i <= (cc); ++i) dfs1(Cr[i], 0, i);
for (int i = (1); i <= (N); ++i) dfs2(i, 0, i, 1);
double ans = 0;
for (int i = (1); i <= (N); ++i)
for (int j = (1); j <= (N); ++j) ans += Calc(i, j);
printf("%.1000f\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
struct _two {
int a, b;
} edge[N + N], p[N];
double ans;
int n, tot, num, pos, tnum;
int st[N], flag[N], stack[N], qu[N], tqu[N];
void Init() {
scanf("%d", &n);
int x, y;
tot = 1;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++;
y++;
edge[++tot] = (_two){y, st[x]};
st[x] = tot;
edge[++tot] = (_two){x, st[y]};
st[y] = tot;
}
}
bool Find_cir(int x, int fa) {
flag[x] = 1;
for (int i = st[x]; i; i = edge[i].b)
if (i != fa) {
if (flag[edge[i].a]) {
pos = edge[i].a;
qu[num = 1] = x;
return 1;
} else if (Find_cir(edge[i].a, i ^ 1)) {
qu[++num] = x;
return x != pos;
}
}
flag[x] = 0;
return 0;
}
void dfs(int x, int fa) {
tqu[++tnum] = x;
for (int i = st[x]; i; i = edge[i].b)
if (!flag[edge[i].a] && i != fa) {
p[edge[i].a] = (_two){p[x].a, p[x].b + 1};
dfs(edge[i].a, i ^ 1);
}
}
void Calc(int x, int fa, int d) {
ans += 1.0 / d;
for (int i = st[x]; i; i = edge[i].b)
if (!flag[edge[i].a] && i != fa) Calc(edge[i].a, i ^ 1, d + 1);
}
void Work() {
Find_cir(1, 0);
for (int i = 1; i <= num; i++) {
tnum = 0;
p[qu[i]] = (_two){i, 0};
flag[qu[i]] = 0;
dfs(qu[i], 0);
for (int j = 1; j <= tnum; j++) Calc(tqu[j], 0, 1);
flag[qu[i]] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (p[i].a != p[j].a) {
int len = ((p[i].a - p[j].a) > 0 ? (p[i].a - p[j].a)
: -(p[i].a - p[j].a)),
ful = num + p[i].b + p[j].b;
ans += 1.0 / (ful - len + 1) + 1.0 / (ful - num + len + 1) - 1.0 / ful;
}
printf("%.7lf\n", ans);
}
int main() {
Init();
Work();
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
double ans;
int n, cnt, C;
int head, tail;
int q[3005], d[3005], d2[3005];
bool vis[3005];
vector<int> e[3005];
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < e[x].size(); i++)
if (!vis[e[x][i]]) {
d2[e[x][i]] = d2[x] + 1;
if (!d[e[x][i]]) {
d[e[x][i]] = d[x] + 1;
ans += 1.0 / d[e[x][i]];
} else
ans =
ans + 1.0 / d2[e[x][i]] - 2.0 / (d[e[x][i]] + d2[e[x][i]] + C - 2);
dfs(e[x][i]);
}
vis[x] = 0;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int u = read(), v = read();
u++;
v++;
e[u].push_back(v);
e[v].push_back(u);
d[u]++;
d[v]++;
}
for (int i = 1; i <= n; i++)
if (d[i] == 1) q[tail++] = i;
while (head != tail) {
int now = q[head];
head++;
for (int i = 0; i < e[now].size(); i++) {
d[e[now][i]]--;
if (d[e[now][i]] == 1) q[tail++] = e[now][i];
}
}
C = n - tail;
for (int i = 1; i <= n; i++) {
memset(d, 0, sizeof(d));
memset(d2, 0, sizeof(d2));
d[i] = d2[i] = 1;
dfs(i);
}
printf("%.10lf\n", ans + n);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3333;
int n;
vector<int> g[N];
int inside[N];
int deg[N];
vector<int> dist0[N], dist1[N];
void dfs(int v, int d0, int d1) {
if (inside[v]) {
return;
}
dist0[v].push_back(d0);
dist1[v].push_back(d1);
inside[v] = 1;
for (int j = 0; j < (int)g[v].size(); j++) {
int u = g[v][j];
int type = (deg[v] + deg[u] <= 3);
dfs(u, d0 + type, d1 + 1 - type);
}
inside[v] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
vector<int> que;
for (int i = 0; i < n; i++) {
deg[i] = g[i].size();
if (deg[i] == 1) {
que.push_back(i);
}
}
for (int i = 0; i < (int)que.size(); i++) {
int v = que[i];
for (int u : g[v]) {
if (deg[u] > 1) {
deg[u]--;
if (deg[u] == 1) {
que.push_back(u);
}
}
}
}
double ans = 0.0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dist0[j].clear();
dist1[j].clear();
}
dfs(i, 1, 1);
for (int j = 0; j < n; j++) {
if (dist0[j].size() == 1) {
ans += 1.0 / dist0[j][0];
} else {
ans += 1.0 / (dist0[j][0] + dist1[j][0] - 1) +
1.0 / (dist0[j][1] + dist1[j][1] - 1) -
1.0 / (dist0[j][0] + dist1[j][0] + dist1[j][1] - 3);
}
}
}
printf("%.20lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using std::max;
using std::min;
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
std::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
inline _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
inline void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
inline void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
inline void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
inline void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
inline int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar++ = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*tar++ = ch, ch = getchar();
return *tar = 0, tar - s;
}
const int N = 3005;
struct edge {
int v, nxt;
} c[N << 1];
int front[N], edge_cnt;
inline void addedge(int u, int v) {
c[++edge_cnt] = (edge){v, front[u]};
front[u] = edge_cnt;
}
int st[N], top;
bool vis[N];
int loop[N], pos, id[N];
void dfs1(int x, int fa) {
if (pos) return;
if (vis[x]) {
while (st[top] != x) {
int tmp = st[top--];
loop[++pos] = tmp;
}
loop[++pos] = x;
return;
}
st[++top] = x, vis[x] = true;
for (int i = front[x]; i; i = c[i].nxt) {
int v = c[i].v;
if (v == fa) continue;
dfs1(v, x);
}
if (pos) return;
--top, vis[x] = false;
}
int dis[N];
void dfs2(int x, int fa) {
dis[x] = dis[fa] + 1;
if (fa) id[x] = id[fa];
for (int i = front[x]; i; i = c[i].nxt) {
int v = c[i].v;
if (v == fa || id[v]) continue;
dfs2(v, x);
}
}
double ans;
void dfs3(int x, int fa, int len) {
ans += 1.0 / (++len);
for (int i = front[x]; i; i = c[i].nxt) {
int v = c[i].v;
if (v == fa || id[v] != id[x]) continue;
dfs3(v, x, len);
}
}
inline double f(int a, int b, int c, int d) {
return (1.0 * b / (a + c + d) + 1.0 * c / (a + b + d) + 1) / (a + b + c + d);
}
int main() {
int n;
read(n);
int x, y;
for (int i = 1; i <= n; ++i)
read(x, y), ++x, ++y, addedge(x, y), addedge(y, x);
dfs1(1, 0);
for (int i = 1; i <= pos; ++i) id[loop[i]] = i;
for (int i = 1; i <= pos; ++i) dfs2(loop[i], 0);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (id[i] != id[j])
ans += f(dis[i], abs(id[i] - id[j]) - 1, pos - abs(id[i] - id[j]) - 1,
dis[j]);
for (int i = 1; i <= n; ++i) dfs3(i, 0, 0);
printf("%.8lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
namespace Fread {
const int MAXN = 1 << 20;
char buffer[MAXN], *S, *T;
inline char getchar() {
if (S == T) {
T = (S = buffer) + fread(buffer, 1, MAXN, stdin);
if (S == T) return EOF;
}
return *S++;
}
} // namespace Fread
inline int read() {
int f = 1, x = 0;
char ch = Fread::getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = Fread::getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = Fread::getchar();
}
return x * f;
}
inline long long readll() {
long long f = 1, x = 0;
char ch = Fread::getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = Fread::getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = Fread::getchar();
}
return x * f;
}
const int MAXN = 3005;
struct EDGE {
int nxt, to;
} edge[MAXN << 1];
int head[MAXN], tot;
inline void add_edge(int u, int v) {
edge[++tot].nxt = head[u];
edge[tot].to = v;
head[u] = tot;
}
int n, sta[MAXN], top, cir[MAXN], c;
bool vis[MAXN], flag, incir[MAXN];
void dfs1(int u, int frm) {
vis[u] = 1;
sta[++top] = u;
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == frm) continue;
if (vis[v]) {
int t = -1;
for (int j = 1; j <= top; ++j)
if (sta[j] == v) {
t = j;
break;
}
assert(t != -1);
for (int j = t; j <= top; ++j) cir[++c] = sta[j];
flag = 1;
return;
}
dfs1(v, u);
if (flag) return;
}
--top;
}
int fa[MAXN], d[MAXN], rt;
vector<int> tr[MAXN];
void dfs2(int u) {
tr[rt].push_back(u);
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == fa[u] || incir[v]) continue;
fa[v] = u;
d[v] = d[u] + 1;
dfs2(v);
}
}
double ans;
void dfs3(int u, int frm, int dep) {
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (incir[u] && incir[v]) continue;
if (v == frm) continue;
ans += 1.0 / (dep + 1);
dfs3(v, u, dep + 1);
}
}
int main() {
n = read();
for (int i = 1, u, v; i <= n; ++i)
u = read() + 1, v = read() + 1, add_edge(u, v), add_edge(v, u);
dfs1(1, 0);
assert(flag);
for (int i = 1; i <= c; ++i) incir[cir[i]] = 1;
for (int i = 1; i <= c; ++i) {
fa[cir[i]] = 0;
rt = cir[i];
dfs2(cir[i]);
}
ans = n;
for (int i = 1; i <= n; ++i) {
dfs3(i, 0, 1);
}
for (int i = 1; i <= c; ++i) {
for (int j = 0; j < (int)tr[cir[i]].size(); ++j) {
int u = tr[cir[i]][j];
for (int k = 1; k <= c; ++k)
if (k != i) {
int dis1 = max(i, k) - min(i, k), dis2 = c - dis1;
for (int l = 0; l < (int)tr[cir[k]].size(); ++l) {
int v = tr[cir[k]][l];
ans += 1.0 / (d[u] + d[v] + dis1 + 1);
ans += 1.0 / (d[u] + d[v] + dis2 + 1);
ans -= 1.0 / (d[u] + d[v] + c);
}
}
}
}
cout << setiosflags(ios::fixed) << setprecision(10) << ans << endl;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> G[3005];
int stk[3005], tp, instk[3005];
vector<int> cyc;
int incyc[3005];
bool flag;
inline void findCycle(int u, int pa) {
stk[++tp] = u;
instk[u] = 1;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == pa) continue;
if (instk[v]) {
while (stk[tp] != v) {
cyc.push_back(stk[tp]);
incyc[stk[tp]] = 1;
instk[stk[tp]] = 0;
--tp;
}
cyc.push_back(stk[tp]);
incyc[stk[tp]] = 1;
instk[stk[tp]] = 0;
--tp;
flag = 1;
} else
findCycle(v, u);
if (flag) return;
}
instk[u] = 0;
--tp;
}
int N;
int anc[3005];
inline void getAnc(int u, int pa, int rt) {
anc[u] = rt;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v != pa && !incyc[v]) getAnc(v, u, rt);
}
}
int dist[3005], len[3005];
double ans;
inline void dfsIn(int u, int pa, int rt) {
dist[u] = dist[pa] + 1;
ans += (double)1 / dist[u];
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v != pa && (!incyc[v] || v == rt)) dfsIn(v, u, rt);
}
}
inline void dfsOut(int u, int pa, int rt) {
dist[u] = dist[pa] + 1;
ans += (double)1 / (dist[u] + len[rt] - 1) +
(double)1 / (dist[u] - len[rt] + N - 1) -
(double)1 / (dist[u] + N - 2);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v != pa && !incyc[v]) dfsOut(v, u, rt);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= (n); ++i) {
int u, v;
cin >> u >> v;
++u, ++v;
G[u].push_back(v);
G[v].push_back(u);
}
findCycle(1, 0);
N = cyc.size();
for (int i = 0; i < (N); ++i) {
int u = cyc[i];
getAnc(u, 0, u);
}
for (int i = 1; i <= (n); ++i) {
double prev = ans;
int rt = anc[i];
dfsIn(i, 0, rt);
int pos = 0;
for (int j = 0; j < (N); ++j)
if (cyc[j] == rt) {
pos = j;
break;
}
for (int j = 0; j < (N); ++j)
if (j != pos) {
len[cyc[j]] = abs(j - pos);
dfsOut(cyc[j], rt, cyc[j]);
}
}
printf("%0.8lf", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const bool db = false;
vector<int> gr[3010];
double res;
int mark[3010], color;
int ds[3010], ds2[3010];
int deg[3010], n, m;
int Len;
void dfs(int v) {
mark[v] = 1;
for (int i = 0, sz = gr[v].size(); i < sz; ++i) {
int to = gr[v][i];
if (mark[to]) continue;
ds2[to] = ds2[v] + 1;
if (ds[to] == 0) {
ds[to] = ds[v] + 1;
res += 1.0 / ds[to];
} else {
res += 1.0 / ds2[to];
res -= 1.0 / ((ds[to] + ds2[to] + Len) / 2 - 1);
}
dfs(to);
}
mark[v] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
x += 1;
y += 1;
gr[x].push_back(y);
gr[y].push_back(x);
++deg[x];
++deg[y];
}
queue<int> q;
for (int i = 1; i <= n; ++i)
if (deg[i] == 1) q.push(i);
Len = n;
res = n;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0, sz = gr[v].size(); i < sz; ++i) {
int to = gr[v][i];
if (--deg[to] == 1) q.push(to);
}
Len -= 1;
}
for (int i = 1; i <= n; ++i) {
memset(ds, 0, sizeof(ds));
memset(ds2, 0, sizeof(ds2));
ds[i] = ds2[i] = 1;
dfs(i);
}
cout.precision(9);
cout << fixed << res << "\n";
getchar();
getchar();
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 3010;
vector<int> e[N], dis[N];
int q[N], n, u, v, t, d[N], vis[N], ct[N];
double ans;
void dfs(int u, int dep, int tc) {
vis[u] = 1;
ct[u] = tc;
dis[u].push_back(dep);
for (int j = 0; j < ((int)(e[u]).size()); j++)
if (!vis[e[u][j]]) dfs(e[u][j], dep + 1, (d[e[u][j]] == 1) + tc);
vis[u] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 0; i < n; i++) d[i] = ((int)(e[i]).size());
for (int i = 0; i < n; i++)
if (d[i] == 1) {
vis[i] = 1;
q[t++] = i;
}
for (int i = 0; i < t; i++)
for (int j = 0; j < ((int)(e[q[i]]).size()); j++) {
int v = e[q[i]][j];
if (!vis[v] && (--d[v]) == 1) {
q[t++] = v;
vis[v] = 1;
}
}
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) dis[j].clear();
dfs(i, 1, d[i] == 1);
for (int j = 0; j < n; j++)
if (((int)(dis[j]).size()) == 1)
ans += 1. / dis[j][0];
else
ans += 1. / dis[j][0] + 1. / dis[j][1] -
1. / (dis[j][0] + dis[j][1] - ct[j] - 2);
}
printf("%.10f\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int M = 3005;
vector<int> eg[M];
int n;
int fa[M], cnt[M], sz[M];
int getfa(int x) {
if (fa[x] == x) return x;
return fa[x] = getfa(fa[x]);
}
double ans;
int pl[M], psz;
int mark[M], TIM;
void dfs_jih_pre(int x) {
pl[psz++] = x;
mark[x] = TIM;
for (int i = 0, up = eg[x].size(); i < up; i++)
if (mark[eg[x][i]] != TIM) dfs_jih_pre(eg[x][i]);
}
vector<int> ps;
void dfs_huan(int x) {
ps.push_back(x);
mark[x] = TIM;
for (int i = 0, up = eg[x].size(); i < up; i++)
if (mark[eg[x][i]] != TIM) dfs_huan(eg[x][i]);
}
vector<int> son[M];
int now;
void dfs_jih(int x, int f, int d) {
pl[psz++] = x;
son[now].push_back(d);
for (int i = 0, up = eg[x].size(); i < up; i++)
if (eg[x][i] != f && mark[eg[x][i]] != TIM) dfs_jih(eg[x][i], x, d + 1);
}
void dfs_jih_tre_calc(int x, int f, int d) {
if (d != 1) ans += 1.0 / d;
for (int i = 0, up = eg[x].size(); i < up; i++)
if (eg[x][i] != f && (mark[eg[x][i]] != TIM || eg[x][i] == now))
dfs_jih_tre_calc(eg[x][i], x, d + 1);
}
void calc_jih(int x) {
TIM++;
psz = 0;
dfs_jih_pre(x);
static int deg[M], q[M], L, R;
L = R = 0;
for (int w = 0; w < psz; w++)
for (int x = pl[w], i = 0, up = eg[x].size(); i < up; i++) deg[eg[x][i]]++;
for (int w = 0; w < psz; w++)
if (deg[pl[w]] == 1) q[R++] = pl[w];
TIM++;
while (L < R) {
static int x;
x = q[L++];
mark[x] = TIM;
for (int i = 0, up = eg[x].size(); i < up; i++)
if (deg[eg[x][i]]-- == 2) q[R++] = eg[x][i];
}
ps.clear();
for (int w = 0; w < psz; w++)
if (mark[pl[w]] != TIM) {
dfs_huan(pl[w]);
break;
}
TIM++;
for (int i = 0, up = ps.size(); i < up; i++) mark[ps[i]] = TIM;
for (int i = 0, up = ps.size(); i < up; i++) {
now = ps[i];
psz = 0;
dfs_jih(now, now, 1);
for (int j = 0; j < psz; j++) dfs_jih_tre_calc(pl[j], pl[j], 1);
}
for (int i = 0, up = ps.size(); i < up; i++)
for (int j = i + 1; j < up; j++) {
int a = ps[i], b = ps[j], c = j - i - 1, d = up - c - 2;
for (int l = 0, upa = son[a].size(); l < upa; l++)
for (int p = 0, upb = son[b].size(); p < upb; p++)
ans += 2.0 * (1.0 / (son[a][l] + son[b][p] + c) +
1.0 / (son[a][l] + son[b][p] + d) -
1.0 / (son[a][l] + son[b][p] + c + d));
}
}
void dfs_tre_pre(int x, int f) {
pl[psz++] = x;
for (int i = 0, up = eg[x].size(); i < up; i++)
if (eg[x][i] != f) dfs_tre_pre(eg[x][i], x);
}
void dfs_tre_calc(int x, int f, int d) {
if (d != 1) ans += 1.0 / d;
for (int i = 0, up = eg[x].size(); i < up; i++)
if (eg[x][i] != f) dfs_tre_calc(eg[x][i], x, d + 1);
}
void calc_tre(int x) {
psz = 0;
dfs_tre_pre(x, x);
for (int i = 0; i < psz; i++) dfs_tre_calc(pl[i], pl[i], 1);
}
int main() {
scanf("%d", &n);
ans = n;
for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1;
for (int i = 1, x, y, faa, fab; i <= n; i++) {
scanf("%d %d", &x, &y);
x++, y++;
eg[x].push_back(y);
eg[y].push_back(x);
faa = getfa(x);
fab = getfa(y);
if (faa != fab) {
fa[faa] = fab;
cnt[fab] += cnt[faa] + 1;
sz[fab] += sz[faa];
} else
cnt[faa]++;
}
for (int i = 1; i <= n; i++)
if (getfa(i) == i) {
if (cnt[i] == sz[i])
calc_jih(i);
else
calc_tre(i);
}
printf("%.15f\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct node_ {
int v, next;
} node[6005];
int head[3005], e, fa[3005][14], gf[3005];
int bj[3005], bjj = 0;
bool b[3005];
void addnode(int u, int v) {
e++;
node[e].v = v;
node[e].next = head[u];
head[u] = e;
}
int flag = 0;
int n;
int dep[3005];
void dfs(int t, int u) {
b[t] = 1;
for (register int i = head[t]; i; i = node[i].next) {
if (u == node[i].v) continue;
if (b[node[i].v]) {
flag = node[i].v;
gf[t] = t;
bj[t] = bjj;
bjj++;
dep[t] = 1;
return;
}
dfs(node[i].v, t);
if (flag > 0) {
gf[t] = t;
bj[t] = bjj;
bjj++;
dep[t] = 1;
if (t == flag) flag = -flag;
return;
} else if (flag < 0)
return;
}
}
void dfs_(int t) {
for (register int i = head[t]; i; i = node[i].next) {
if (gf[node[i].v]) continue;
gf[node[i].v] = gf[t];
fa[node[i].v][0] = t;
for (register int j = 1; j <= 11; ++j)
fa[node[i].v][j] = fa[fa[node[i].v][j - 1]][j - 1];
dep[node[i].v] = dep[t] + 1;
dfs_(node[i].v);
}
}
int log_[3005];
int lca(int u, int v) {
if (dep[v] > dep[u]) swap(u, v);
while (dep[u] > dep[v]) {
u = fa[u][log_[dep[u] - dep[v]]];
}
if (u == v) return u;
for (register int i = 11; i >= 0; --i) {
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
}
return fa[u][0];
}
double ans = 0;
int main() {
scanf("%d", &n);
for (register int i = 2; i <= n; ++i) {
log_[i] = log_[i / 2] + 1;
}
for (register int i = 1; i <= n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
u++;
v++;
addnode(u, v);
addnode(v, u);
}
dfs(1, 1);
for (register int i = 1; i <= n; ++i) {
if (gf[i] == i) {
dfs_(i);
}
}
for (register int i = 1; i <= n; ++i) {
for (register int j = 1; j <= n; ++j) {
if (gf[i] == gf[j]) {
ans += (1 / (double)(dep[i] + dep[j] - 2 * dep[lca(i, j)] + 1));
} else {
int x = dep[i] + dep[j], y = abs(bj[gf[i]] - bj[gf[j]]) - 1,
z = bjj - 1 - abs(bj[gf[i]] - bj[gf[j]]);
ans = ans + 1 / (double)(x + z) + 1 / (double)(x + y) -
1 / (double)(x + z + y);
}
}
}
printf("%.9lf", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int c[3050 * 2][2], ss = 1, h[3050][2], fi[3050], n, m, len;
bool b[3050], flag = false;
double ans;
inline int Read() {
int x = 0;
char y;
do y = getchar();
while (y < '0' || y > '9');
do x = x * 10 + y - '0', y = getchar();
while (y >= '0' && y <= '9');
return x;
}
inline void Line(int x, int y) {
c[++ss][0] = y;
c[ss][1] = fi[x];
fi[x] = ss;
c[++ss][0] = x;
c[ss][1] = fi[y];
fi[y] = ss;
}
bool DFS(int x, int y, int z, int o) {
if (x == z) {
len = y + 1;
return true;
}
for (int i = fi[x]; i; i = c[i][1])
if (c[i][0] != o && DFS(c[i][0], y + 1, z, x)) return true;
return false;
}
void DSF(int x, int y, int z, int o) {
h[x][h[x][0] > 0] = y;
b[x] = 1;
for (int i = fi[x]; i; i = c[i][1])
if (c[i][0] != o && c[i][0] != z && !b[c[i][0]]) DSF(c[i][0], y + 1, x, o);
b[x] = 0;
}
int main() {
n = Read();
for (int i = 1; i <= n; i++) {
int k = Read() + 1, l = Read() + 1;
if (!flag) flag = DFS(k, 0, l, 0);
Line(k, l);
}
for (int i = 1; i <= n; i++) {
memset(h, 0, sizeof(h));
DSF(i, 1, 0, i);
for (int j = 1; j <= n; j++)
if (!h[j][1])
ans += 1.0 / h[j][0];
else
ans +=
1.0 / h[j][0] + 1.0 / h[j][1] - 2.0 / (h[j][0] + h[j][1] + len - 2);
}
printf("%.9lf\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 998244353;
const int MAXN = 600005;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
double ans;
vector<int> e[MAXN];
int vis[MAXN], stk[MAXN], a[MAXN], id[MAXN], gf[MAXN], dis[MAXN], rt, top = 0,
num = 0;
void dfs(int x, int father) {
vis[x] = 1, stk[++top] = x;
for (auto v : e[x]) {
if (v == father) continue;
if (vis[v]) {
if (num) continue;
int y;
while (y = stk[top--]) {
a[++num] = y, id[y] = num;
if (y == v) break;
}
} else
dfs(v, x);
}
if (stk[top] == x) top--;
}
void Dfs(int x, int father, int Gf) {
gf[x] = Gf;
dis[x] = dis[father] + 1;
for (auto v : e[x])
if (!id[v] && v != father) Dfs(v, x, Gf);
}
void getans(int x, int dep) {
vis[x] = 1;
if (x != rt) {
if (gf[x] == gf[rt])
ans += (double)1 / (double)dep;
else {
int a = dis[x] + dis[rt], b = abs(id[gf[x]] - id[gf[rt]]) - 1,
c = num - 2 - b;
ans += (double)1 / ((double)a + b) + (double)1 / ((double)a + c) -
(double)1 / ((double)a + b + c);
}
}
for (auto v : e[x])
if (!vis[v]) getans(v, dep + 1);
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
int u = read() + 1, v = read() + 1;
e[u].push_back(v), e[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= num; i++) Dfs(a[i], 0, a[i]);
ans = (double)n;
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof vis);
rt = i, getans(i, 1);
}
printf("%.10lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
vector<int> adj[3333];
int n;
int deg[3333];
int col[3333];
int rc;
int q[3333], qf, qb;
int deep[3333];
int dst[3333][3333];
void dfs(int u, int fa = 0) {
deep[u] = deep[fa] + 1;
for (int v : adj[u]) {
if (v == fa) continue;
if (col[v] >= 0) continue;
col[v] = col[u];
dfs(v, u);
}
}
void ser(int u, int fa, int root) {
for (int v : adj[u]) {
if (v == fa or col[u] != col[v]) continue;
dst[root][v] = dst[root][u] + 1;
ser(v, u, root);
}
}
double ans;
void calc(int u, int v) {
if (col[u] == col[v]) {
ans += 1.0 / (dst[u][v] + 1);
return;
}
int X = deep[u] + deep[v];
int Y = abs(col[u] - col[v]) - 1;
int Z = rc - Y - 2;
ans += 1.0 / (X + Y) + 1.0 / (X + Z) - 1.0 / (X + Y + Z);
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
int u, v;
gn(u);
gn(v);
u++;
v++;
adj[u].push_back(v);
adj[v].push_back(u);
deg[u]++;
deg[v]++;
}
for (int i = 1; i <= n; i++)
if (deg[i] == 1) q[qb++] = i;
while (qb > qf) {
int u = q[qf++];
col[u] = -1;
for (int v : adj[u]) {
deg[v]--;
if (deg[v] == 1) q[qb++] = v;
}
}
for (int i = 1; i <= n; i++)
if (col[i] == 0) col[i] = ++rc, dfs(i);
for (int i = 1; i <= n; i++) {
ser(i, 0, i);
for (int j = 1; j <= n; j++) {
calc(i, j);
}
}
printf("%.10lf\n", ans);
}
int main() {
solve();
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct bian {
int next, point;
} b[7000];
int p[4000], n, len, pd[4000], x[4000], s[4000], head, bo[4000], d[4000],
u[4000];
long double ans;
void ade(int k1, int k2) {
b[++len] = (bian){p[k1], k2};
p[k1] = len;
}
void add(int k1, int k2) {
ade(k1, k2);
ade(k2, k1);
}
void dfs(int k1, int k2) {
if (bo[k1]) {
while (s[head + 1] != k1) {
x[++len] = s[head];
d[x[len]] = len;
pd[s[head]] = 1;
head--;
}
return;
}
bo[k1] = 1;
s[++head] = k1;
for (int i = p[k1]; i != -1; i = b[i].next) {
int j = b[i].point;
if ((i ^ 1) != k2) dfs(j, i);
if (len) return;
}
head--;
}
void dfs2(int k1, int k2, int k3, int k4) {
d[k1] = k3;
u[k1] = k4;
for (int i = p[k1]; i != -1; i = b[i].next) {
int j = b[i].point;
if (j != k2 && pd[j] == 0) dfs2(j, k1, k3, k4 + 1);
}
}
void dfs3(int k1, int k2, int k3) {
ans += 1 / (double)k3;
for (int i = p[k1]; i != -1; i = b[i].next) {
int j = b[i].point;
if (pd[j] == 0 && j != k2) dfs3(j, k1, k3 + 1);
}
}
int main() {
scanf("%d", &n);
len = -1;
memset(p, 0xff, sizeof p);
for (int i = 1; i <= n; i++) {
int k1, k2;
scanf("%d%d", &k1, &k2);
k1++;
k2++;
add(k1, k2);
}
len = 0;
dfs(1, -100);
for (int i = 1; i <= n; i++)
if (pd[i]) dfs2(i, 0, d[i], 0);
ans = 0;
for (int i = 1; i <= n; i++) {
pd[x[d[i]]] = 0;
dfs3(i, 0, 1);
pd[x[d[i]]] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (d[i] != d[j]) {
int k1 = u[i] + u[j], k2 = abs(d[i] - d[j]) + 1, k3 = len - k2 + 2;
ans += 1 / (double)(k1 + k2) + 1 / (double)(k1 + k3) -
1 / (double)(k1 + len);
}
printf("%.11lf", (double)ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
using namespace std;
int n;
struct edge {
int nxt;
int to;
} e[4223 << 1];
int head[4223], ecnt = 1;
inline void addedge(int from, int to) {
e[++ecnt] = (edge){head[from], to};
head[from] = ecnt;
}
int d[4223];
int que[4223 << 1], front, rear;
bool notcir[4223];
bool incir[4223 << 1];
inline void topo() {
for (register int i = 1; i <= n; ++i)
if (d[i] == 1) que[++rear] = i, notcir[i] = true;
while (front < rear) {
int cur = que[++front];
for (register int i = head[cur]; i; i = e[i].nxt) {
int to = e[i].to;
if (notcir[to]) continue;
--d[to];
if (d[to] == 1) {
notcir[to] = true;
que[++rear] = to;
}
}
}
for (register int p = 1; p <= n; ++p)
if (!notcir[p])
for (register int i = head[p]; i; i = e[i].nxt) {
int to = e[i].to;
if (notcir[to]) continue;
incir[i] = true;
}
}
double f[4223][4223];
void dfs_in_tree(int u, int cur, int depp, int faa) {
f[u][cur] = f[cur][u] = 1.0 / depp;
for (register int i = head[cur]; i; i = e[i].nxt) {
int to = e[i].to;
if (incir[i] || to == faa) continue;
dfs_in_tree(u, to, depp + 1, cur);
}
}
int h[4223], htot;
bool vis[4223];
void find_cir(int cur) {
h[++htot] = cur;
vis[cur] = true;
for (register int i = head[cur]; i; i = e[i].nxt)
if (incir[i]) {
int to = e[i].to;
if (!vis[to]) find_cir(to);
}
}
void dfs3(int cur, int u, int y, int z, int x, int faa) {
f[cur][u] = f[u][cur] = 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
for (register int i = head[cur]; i; i = e[i].nxt)
if (!incir[i]) {
int to = e[i].to;
if (to == faa) continue;
dfs3(to, u, y, z, x + 1, cur);
}
}
void dfs2(int cur, int v, int y, int z, int x, int faa) {
dfs3(v, cur, y, z, x + 1, 0);
for (register int i = head[cur]; i; i = e[i].nxt)
if (!incir[i]) {
int to = e[i].to;
if (to == faa) continue;
dfs2(to, v, y, z, x + 1, cur);
}
}
inline void Cir() {
for (register int i = 1; i <= n; ++i)
if (!notcir[i]) {
find_cir(i);
break;
}
for (register int i = 1; i <= htot; ++i)
for (register int j = i + 1; j <= htot; ++j)
dfs2(h[i], h[j], j - i - 1, htot - j + i - 1, 1, 0);
}
int main() {
read(n);
for (register int i = 1; i <= n; ++i) {
int u, v;
read(u), read(v);
++u, ++v;
addedge(u, v), addedge(v, u);
++d[u], ++d[v];
}
topo();
for (register int i = 1; i <= n; ++i) dfs_in_tree(i, i, 1, 0);
Cir();
double res = 0;
for (register int i = 1; i <= n; ++i)
for (register int j = 1; j <= n; ++j) res += f[i][j];
printf("%.10lf\n", res);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int lca[3005][3005];
int last[3005];
int cir[3005];
int lab[3005];
int par[3005];
int pre[6005];
int dep[3005];
int e[6005];
int f[3005];
int h[3005];
int n, m, cnt;
int find_cir(int x, int par, int cirst) {
int i;
h[x] = 1;
for (i = last[x]; i != 0; i = pre[i])
if (e[i] != par)
if (e[i] == cirst || (!h[e[i]] && find_cir(e[i], x, cirst))) {
cir[++cnt] = x;
return 1;
}
return 0;
}
void dfs(int x) {
int i;
for (i = last[x]; i; i = pre[i])
if (e[i] != par[x] && lab[e[i]] == 0) {
f[e[i]] = f[x];
par[e[i]] = x;
dep[e[i]] = dep[x] + 1;
dfs(e[i]);
}
}
int find(int u, int v) {
if (lca[u][v]) return lca[u][v];
if (u == v) return lca[u][v] = u;
if (dep[u] > dep[v])
lca[u][v] = find(par[u], v);
else
lca[u][v] = find(u, par[v]);
return lca[u][v];
}
double work() {
int i, j, x, y, z;
double ans = 0;
for (i = 1; i <= n; ++i) {
cnt = 0;
memset(h, 0, sizeof h);
if (find_cir(i, 0, i)) break;
}
for (i = 1; i <= cnt; ++i) {
dep[cir[i]] = 1;
f[cir[i]] = cir[i];
lab[cir[i]] = i;
dfs(cir[i]);
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
if (f[i] == f[j]) {
x = find(i, j);
y = dep[i] - dep[x] + dep[j] - dep[x] + 1;
ans += 1.0 / y;
} else {
x = dep[i] + dep[j];
y = (lab[f[i]] - lab[f[j]] + cnt) % cnt - 1;
z = (lab[f[j]] - lab[f[i]] + cnt) % cnt - 1;
ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
return ans;
}
int main() {
int i, j, a, b;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d %d", &a, &b);
++a, ++b;
(e[++m] = b, pre[m] = last[a], last[a] = m),
(e[++m] = a, pre[m] = last[b], last[b] = m);
}
printf("%.10lf\n", work());
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005, M = N << 1;
int n, tot, len, du[N], now[N], prep[M], son[M];
double ans;
void read(int &x) {
x = 0;
int f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
void link(int u, int v) {
tot++, prep[tot] = now[u], now[u] = tot, son[tot] = v;
}
void init() {
read(n);
tot = 0, memset(now, 0, sizeof(now));
for (int u, v, i = 1; i <= n; i++) {
read(u), u++, read(v), v++;
link(u, v), link(v, u), du[u]++, du[v]++;
}
}
void topsort() {
int q[N], top;
top = 0;
for (int i = 1; i <= n; i++)
if (du[i] == 1) q[++top] = i;
for (int i = 1; i <= top; i++) {
int x = q[i];
for (int j = now[x]; j; j = prep[j]) {
int y = son[j];
if ((--du[y]) == 1) q[++top] = y;
}
}
len = n - top;
}
int d1[N], d2[N];
bool vis[N];
void dfs(int x, int y) {
if (!d1[x])
d1[x] = y;
else
d2[x] = y;
vis[x] = 1;
for (int i = now[x]; i; i = prep[i]) {
int to = son[i];
if (!vis[to]) dfs(to, y + 1);
}
vis[x] = 0;
}
void solve() {
ans = 0;
for (int i = 1; i <= n; i++) {
memset(d1, 0, sizeof(d1));
memset(d2, 0, sizeof(d2));
dfs(i, 1);
for (int j = 1; j <= n; j++) {
if (!d2[j])
ans += 1.0 / d1[j];
else
ans += 1.0 / d1[j] + 1.0 / d2[j] - 2.0 / (d1[j] + d2[j] - 2 + len);
}
}
printf("%.7lf\n", ans);
}
void judge() {
freopen("dierti.in", "r", stdin);
freopen("dierti.out", "w", stdout);
}
int main() {
init();
topsort();
solve();
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int NN = 3011;
inline int read() {
int t = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') f = (ch == '-') ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') t = t * 10 + ch - '0', ch = getchar();
return t * f;
}
double ans = 0;
int n, tot = 0, a[NN << 1], num[NN], fa[NN];
bool huan[NN], vt[NN];
int cc = 1, to[NN << 1], nex[NN << 1], o[NN];
inline void add(int x, int y) {
to[++cc] = y, nex[cc] = o[x], o[x] = cc;
to[++cc] = x, nex[cc] = o[y], o[y] = cc;
}
bool dfs(int x, int pre) {
vt[x] = 1;
for (int k = o[x]; k; k = nex[k]) {
if ((k ^ 1) == pre) continue;
int y = to[k];
if (vt[y]) {
a[++tot] = y, huan[y] = 1;
while (x != y) huan[x] = 1, a[++tot] = x, x = fa[x];
return 1;
}
fa[y] = x;
if (dfs(y, k)) return 1;
}
return 0;
}
void work(int x, int t1, int t2) {
vt[x] = 1;
if (t2 < 0)
ans += 1.0 / t1;
else
ans += 1.0 / t1 + 1.0 / t2 - 1.0 / ((t1 + t2 - 2 - tot) / 2 + tot);
if (huan[x] && t2 < 0 && tot > 1) {
int now = num[x];
for (int i = now + 1; i <= now + tot - 1; i++) vt[a[i]] = 1;
for (int i = 1; i <= tot - 1; i++) work(a[now + i], t1 + i, t1 + tot - i);
}
for (int k = o[x]; k; k = nex[k]) {
int y = to[k];
if (vt[y]) continue;
work(y, t1 + 1, t2 + 1);
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) add(read() + 1, read() + 1);
dfs(1, 0);
for (int i = 1; i <= tot; i++) a[tot + i] = a[i], num[a[i]] = i;
for (int i = 1; i <= n; i++) {
memset(vt, 0, sizeof(bool) * (n + 10));
work(i, 1, -inf);
}
printf("%.10lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
int n, ai, bi;
vector<int> G[MAXN];
int deg[MAXN];
vector<pair<int, int> > C[MAXN];
int nxt(int i, int p) {
for (int j : G[i])
if (deg[j] == 2) {
if (j == p) continue;
return j;
}
return -1;
}
double prob(int d) { return 2.0 / d; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &ai, &bi);
G[ai].push_back(bi);
G[bi].push_back(ai);
deg[ai]++;
deg[bi]++;
}
for (int i = 0; i < n; i++) C[i].push_back({i, 1});
queue<int> q;
for (int i = 0; i < n; i++)
if (deg[i] == 1) q.push(i);
double totalCost = n;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : G[u]) {
if (deg[v] == 1) continue;
deg[v]--;
if (deg[v] == 1) q.push(v);
for (pair<int, int> a : C[v])
for (pair<int, int> b : C[u]) {
int d = a.second + b.second;
totalCost += prob(d);
}
for (pair<int, int> b : C[u]) C[v].push_back({b.first, b.second + 1});
}
}
int cycleSize = 0;
for (int i = 0; i < n; i++) cycleSize += (deg[i] == 2);
for (int i = 0; i < n; i++)
if (deg[i] == 2) {
int v = nxt(i, i), p = i, vd = 0;
while (v != i) {
if (i < v) {
for (pair<int, int> a : C[i])
for (pair<int, int> b : C[v]) {
int d = a.second + b.second + vd;
int d2 = a.second + b.second + (cycleSize - vd - 2);
int ud = a.second + b.second + cycleSize - 2;
totalCost += prob(d);
totalCost += prob(d2);
totalCost -= prob(ud);
}
}
int nv = nxt(v, p);
p = v;
v = nv;
vd++;
}
}
printf("%.15f\n", totalCost);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 100005;
int N, loid[MXN], islolo[MXN];
int bln[MXN], dep[MXN];
vector<int> E[MXN];
vector<int> lolo;
int ins[MXN];
vector<int> stk;
long double ans;
bool DFS1(int u, int f) {
ins[u] = 1;
stk.push_back(u);
for (auto v : E[u]) {
if (v == f) continue;
if (ins[v]) {
while (stk.back() != v) {
lolo.push_back(stk.back());
stk.pop_back();
}
lolo.push_back(v);
return 1;
}
if (DFS1(v, u)) return 1;
}
ins[u] = 0;
stk.pop_back();
return 0;
}
void DFS(int u, int f, int d, int bid) {
dep[u] = d;
bln[u] = bid;
for (auto v : E[u]) {
if (v == f) continue;
if (islolo[v]) continue;
DFS(v, u, d + 1, bid);
}
}
void calc(int u, int f, int d) {
ans += 1.0 / d;
for (auto v : E[u]) {
if (v == f) continue;
if (islolo[v] and bln[u] != v) continue;
calc(v, u, d + 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> N;
for (int i = 0; i < (N); i++) {
int u, v;
cin >> u >> v;
E[u].push_back(v);
E[v].push_back(u);
}
DFS1(0, 0);
for (int i = 0; i < (((int)((lolo).size()))); i++) {
int v = lolo[i];
loid[v] = i;
islolo[v] = 1;
}
for (auto v : lolo) DFS(v, v, 1, v);
ans = 0;
for (int i = 0; i < (N); i++) calc(i, i, 1);
for (int i = 0; i < (N); i++)
for (int j = 0; j < (N); j++) {
if (i == j) continue;
if (bln[i] == bln[j]) continue;
int d1 = abs(loid[bln[i]] - loid[bln[j]]);
int d2 = ((int)((lolo).size())) - d1;
d1--;
d2--;
ans += 1.0 / (dep[i] + dep[j] + d1);
ans += 1.0 / (dep[i] + dep[j] + d2);
ans -= 1.0 / (dep[i] + dep[j] + d1 + d2);
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, m, dep[5000], id[5000], cnt, sum, acc[5000], lca[3020][3020], f[5000];
int dfn[5000], low[5000], ist[5000], belong[5000], tot[5000], maxid;
double Ans;
stack<int> a;
vector<int> v[5000];
inline void tarjan(int x, int fa) {
dfn[x] = low[x] = ++cnt;
a.push(x);
ist[x] = 1;
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] != fa) {
if (!dfn[v[x][i]]) {
tarjan(v[x][i], x);
low[x] = min(low[x], low[v[x][i]]);
} else if (ist[v[x][i]]) {
low[x] = min(low[x], dfn[v[x][i]]);
}
}
if (low[x] == dfn[x]) {
sum++;
while (1) {
int u = a.top();
a.pop();
ist[u] = 0;
belong[u] = sum;
tot[sum]++;
if (u == x) break;
}
}
}
inline int sf(int x) { return f[x] == x ? x : f[x] = sf(f[x]); }
inline void work(int x, int ac, int fa) {
acc[x] = ac;
f[x] = x;
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] != fa && tot[belong[v[x][i]]] == 1) {
dep[v[x][i]] = dep[x] + 1;
work(v[x][i], ac, x);
if (sf(v[x][i]) != sf(x)) f[sf(v[x][i])] = sf(x);
}
for (int i = 1; i <= n; i++)
if (acc[i] == ac) lca[x][i] = lca[i][x] = sf(i);
}
inline void dfs(int x, int fa) {
id[x] = id[fa] + 1, dep[x] = 1, acc[x] = x;
work(x, x, x);
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] != fa && !id[v[x][i]]) {
if (tot[belong[v[x][i]]] > 1) dfs(v[x][i], x);
}
}
int main() {
int i, j, k, x, y;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++, y++;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
for (i = 1; i <= n; i++)
if (tot[belong[i]] > 1) {
id[i] = 1;
maxid = tot[belong[i]];
dfs(i, 0);
break;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
if (acc[i] == acc[j])
Ans += 1.0 / (dep[i] + dep[j] - 2 * dep[lca[i][j]] + 1);
else {
int x = dep[i] + dep[j], y = abs(id[acc[i]] - id[acc[j]]) - 1,
z = maxid - y - 2;
Ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
}
printf("%0.7lf\n", Ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxlog = 13;
const int maxn = 3003;
int n;
vector<int> g[maxn];
bool vis[maxn], mark[maxn];
int pos[maxn], cnt;
int dis[maxn], r[maxn], d[maxn][maxlog];
long double ans;
void go(int v, int u) {
if (mark[v]) return;
for (int i = 0; v != d[u][0]; i++) {
mark[v] = true;
cnt++;
pos[v] = i;
v = d[v][0];
}
}
void find_cycle(int v, int par = -1) {
d[v][0] = par;
vis[v] = true;
for (int u : g[v])
if (u != par)
if (vis[u])
go(v, u);
else
find_cycle(u, v);
}
void dfs(int v, int par = -1, int root = -1) {
if (par == -1) par = root = v;
dis[v] = dis[par] + 1;
r[v] = root;
d[v][0] = par;
for (int i = 1; i < maxlog; i++) d[v][i] = d[d[v][i - 1]][i - 1];
for (int u : g[v])
if (!mark[u] and u != par) dfs(u, v, root);
}
int dad(int v, int h) {
for (int i = maxlog; i--;)
if (dis[d[v][i]] >= h) v = d[v][i];
return v;
}
int lca(int v, int u) {
if (dis[v] > dis[u]) swap(v, u);
u = dad(u, dis[v]);
if (v == u) return v;
for (int i = maxlog; i--;)
if (d[v][i] != d[u][i]) v = d[v][i], u = d[u][i];
return d[v][0];
}
int pv, pu, l, l1, l2;
long double f(int v, int u) {
pv = pos[r[v]], pu = pos[r[u]];
if (pv == pu) {
l = dis[v] + dis[u] - 2 * dis[lca(v, u)];
return 1.0 / (l + 1);
} else {
l = cnt;
l1 = dis[v] + dis[u] - 2 + (pv - pu + l) % l;
l2 = dis[v] + dis[u] - 2 + (pu - pv + l) % l;
return 1.0 / (l1 + 1) + 1.0 / (l2 + 1) - 1.0 / (l + dis[v] + dis[u] - 2);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int v, u, i = 0; i < n; i++) {
cin >> v >> u;
g[v].push_back(u);
g[u].push_back(v);
}
find_cycle(0);
for (int i = 0; i < n; i++)
if (mark[i]) dfs(i);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) ans += f(i, j);
ans = ans + ans + n;
cout << setprecision(15) << fixed << ans << endl;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3000 + 3;
struct Edge {
int to, nxt;
} e[N << 1];
int n, cnt;
int hd[N], top, q[N], tail, cur[N], c[N], pos[N], belong[N], fa[N][13], dep[N];
bool vis[N], used[N];
long double ans;
inline void addedge(int x, int y) {
e[++top].to = y;
e[top].nxt = hd[x];
hd[x] = top;
e[++top].to = x;
e[top].nxt = hd[y];
hd[y] = top;
}
inline void find_cycle(void) {
int tail, now;
for (int i = 1; i <= n; ++i) cur[i] = hd[i];
for (vis[q[tail = 1] = 1] = 1; tail;)
for (int& p = cur[now = q[tail]]; ~p; p = e[p].nxt)
if (!used[p >> 1]) {
used[p >> 1] = 1;
if (vis[e[p].to]) {
do c[++cnt] = q[tail--];
while (c[cnt] != e[p].to);
return;
}
vis[q[++tail] = e[p].to] = 1;
p = e[p].nxt;
break;
} else if (!~e[p].nxt) {
--tail;
break;
}
}
inline void init(void) {
find_cycle();
memset(vis, 0, sizeof vis);
for (int i = 1; i <= cnt; ++i) vis[c[i]] = 1;
for (int i = 1, l, r, now, p; i <= cnt; ++i) {
pos[c[i]] = i;
for (fa[q[l = r = 1] = c[i]][0] = -1; l <= r; ++l) {
for (p = hd[now = q[l]]; ~p; p = e[p].nxt)
if (!vis[e[p].to])
vis[q[++r] = e[p].to] = 1,
dep[e[p].to] = dep[fa[e[p].to][0] = now] + 1;
}
for (int j = 1; j <= r; belong[q[j++]] = c[i])
for (int k = 0; k < 12; ++k)
fa[q[j]][k + 1] = ~fa[q[j]][k] ? fa[fa[q[j]][k]][k] : -1;
}
}
inline int lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
for (int k = 12; ~k && dep[x] != dep[y]; --k)
if (~fa[y][k] && dep[fa[y][k]] >= dep[x]) y = fa[y][k];
for (int k = 12; ~k && x != y; --k)
if (~fa[x][k] && ~fa[y][k] && fa[x][k] != fa[y][k])
x = fa[x][k], y = fa[y][k];
return x == y ? x : fa[x][0];
}
inline void solve(int x, int y) {
if (belong[x] == belong[y]) {
int z = lca(x, y);
ans += 1.0 / (dep[x] + dep[y] - dep[z] * 2 + 1);
} else {
int a = dep[x] + dep[y], b = abs(pos[belong[x]] - pos[belong[y]]) - 1,
c = cnt - 2 - b;
ans += 1.0 / (a + b + 2) + 1.0 / (a + c + 2) - 1.0 / (a + cnt);
}
}
int main(int argc, char** argv) {
int x, y;
memset(hd, -1, sizeof hd);
top = -1;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", &x, &y), addedge(x + 1, y + 1);
init();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) solve(i, j);
printf("%.10lf\n", (double)ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
stack<int> st;
int head[333000], cnt, ins[333000], is[333000], c[333000], id[333000], le,
vis[333000], ntt[333000], s1[333000], s2[333000], s3[333000], s4[333000],
s5[333000], sth[2220000 * 5], lb[333000], len[333000], rev[333000], n, m, a,
b, ds[333000], mx1, vl, as, sz[333000], mx2, ct2;
struct edge {
int t, next;
} ed[333000 * 2];
void adde(int f, int t) {
ed[++cnt] = (edge){t, head[f]};
head[f] = cnt;
ed[++cnt] = (edge){f, head[t]};
head[t] = cnt;
}
int pw(int a, int p) {
int ans = 1;
while (p) {
if (p & 1) ans = 1ll * ans * a % 998244353;
a = 1ll * a * a % 998244353;
p >>= 1;
}
return ans;
}
void dft(int s, int *a, int t) {
for (int i = 0; i < s; i++) rev[i] = (rev[i >> 1] >> 1) + (i & 1) * s / 2;
for (int i = 0; i < s; i++) ntt[rev[i]] = a[i];
for (int l = 2; l <= s; l <<= 1) {
int s1 = pw(3, (998244353 - 1) / l);
if (t == -1) s1 = pw(s1, 998244353 - 2);
for (int j = 0; j < s; j += l)
for (int k = j, st = 1; k < j + (l >> 1);
k++, st = 1ll * st * s1 % 998244353) {
int a1 = ntt[k], a2 = 1ll * ntt[k + (l >> 1)] * st % 998244353;
ntt[k] = a1 + a2 - (a1 + a2 >= 998244353 ? 998244353 : 0);
ntt[k + (l >> 1)] = a1 - a2 + (a1 < a2 ? 998244353 : 0);
}
}
int inv = pw(s, t == -1 ? 998244353 - 2 : 0);
for (int i = 0; i < s; i++) a[i] = 1ll * ntt[i] * inv % 998244353;
}
void dfs0(int u, int fa) {
ins[u] = 1;
st.push(u);
for (int i = head[u]; i && !le; i = ed[i].next)
if (ed[i].t != fa) {
if (ins[ed[i].t]) {
while (1) {
int a = st.top();
st.pop();
c[++le] = a;
if (a == ed[i].t) break;
}
} else
dfs0(ed[i].t, u);
}
if (!st.empty() && st.top() == u) st.pop();
}
void dfs1(int u, int fa) {
sz[u] = 1;
int mx = 0;
for (int i = head[u]; i; i = ed[i].next)
if (ed[i].t != fa && !vis[ed[i].t])
dfs1(ed[i].t, u), mx = max(mx, sz[ed[i].t]), sz[u] += sz[ed[i].t];
mx = max(mx, vl - sz[u]);
if (mx < mx1) mx1 = mx, as = u;
}
void dfs2(int u, int fa) {
ds[u] = ds[fa] + 1;
s2[ds[u]]++;
if (mx2 < ds[u]) mx2 = ds[u];
for (int i = head[u]; i; i = ed[i].next)
if (ed[i].t != fa && !vis[ed[i].t]) dfs2(ed[i].t, u);
}
void work(int u) {
int mx = 0;
ds[u] = 0;
for (int i = head[u]; i; i = ed[i].next)
if (!vis[ed[i].t]) {
mx2 = 0;
dfs2(ed[i].t, u);
for (int i = 1; i <= mx2; i++) s1[i] += s2[i], s3[i] = s2[i], s2[i] = 0;
int l = 1;
while (l <= mx2 * 2) l <<= 1;
for (int i = mx2 + 1; i < l; i++) s3[i] = 0;
dft(l, s3, 1);
for (int i = 0; i < l; i++) s3[i] = 1ll * s3[i] * s3[i] % 998244353;
dft(l, s3, -1);
for (int i = 0; i < l; i++)
s4[i] = (s4[i] - s3[i] + 998244353) % 998244353;
if (mx < mx2) mx = mx2;
}
int l = 1;
while (l <= mx * 2) l <<= 1;
for (int i = mx + 1; i < l; i++) s1[i] = 0;
dft(l, s1, 1);
for (int i = 0; i < l; i++) s1[i] = 1ll * s1[i] * (s1[i] + 2) % 998244353;
dft(l, s1, -1);
for (int i = 0; i < l; i++) s4[i] = (s4[i] + s1[i]) % 998244353, s1[i] = 0;
return;
}
void dfs3(int u) {
vis[u] = 1;
work(u);
for (int i = head[u]; i; i = ed[i].next)
if (!vis[ed[i].t]) {
vl = sz[ed[i].t], mx1 = 1e9;
dfs1(ed[i].t, u);
dfs3(as);
}
}
void fz1(int l, int r) {
if (l >= r) return;
int mid = (l + r) >> 1;
int m1 = 0, m2 = 0;
for (int i = l; i <= mid; i++) m1 = max(len[i] + mid - i, m1);
for (int i = mid + 1; i <= r; i++) m2 = max(len[i] + i - mid - 1, m2);
for (int i = 0; i <= m1; i++) s1[i] = 0;
for (int i = 0; i <= m2; i++) s2[i] = 0;
for (int i = l; i <= mid; i++)
for (int j = 0; j <= len[i]; j++) s1[mid - i + j] += sth[j + lb[i]];
for (int i = mid + 1; i <= r; i++)
for (int j = 0; j <= len[i]; j++) s2[i - mid - 1 + j] += sth[j + lb[i]];
int s = 1;
while (s <= m1 + m2) s <<= 1;
for (int i = m1 + 1; i < s; i++) s1[i] = 0;
for (int i = m2 + 1; i < s; i++) s2[i] = 0;
dft(s, s1, 1);
dft(s, s2, 1);
for (int i = 0; i < s; i++) s1[i] = 2ll * s1[i] * s2[i] % 998244353;
dft(s, s1, -1);
for (int i = 0; i < s; i++) s4[i + 1] = (s4[i + 1] + s1[i]) % 998244353;
fz1(l, mid);
fz1(mid + 1, r);
}
void fz2(int l, int r) {
if (l >= r) return;
int mid = (l + r) >> 1;
int m1 = 0, m2 = 0;
for (int i = l; i <= mid; i++) m1 = max(len[i] + i - l, m1);
for (int i = mid + 1; i <= r; i++) m2 = max(len[i] + r - i, m2);
for (int i = 0; i <= m1; i++) s1[i] = 0;
for (int i = 0; i <= m2; i++) s2[i] = 0;
for (int i = l; i <= mid; i++)
for (int j = 0; j <= len[i]; j++) s1[i - l + j] += sth[j + lb[i]];
for (int i = mid + 1; i <= r; i++)
for (int j = 0; j <= len[i]; j++) s2[r - i + j] += sth[j + lb[i]];
int s = 1;
while (s <= m1 + m2) s <<= 1;
for (int i = m1 + 1; i < s; i++) s1[i] = 0;
for (int i = m2 + 1; i < s; i++) s2[i] = 0;
dft(s, s1, 1);
dft(s, s2, 1);
for (int i = 0; i < s; i++) s1[i] = 2ll * s1[i] * s2[i] % 998244353;
dft(s, s1, -1);
for (int i = 0; i < s; i++)
s4[i + le - r + l] = (s4[i + le - r + l] + s1[i]) % 998244353;
fz2(l, mid);
fz2(mid + 1, r);
}
int main() {
scanf("%d", &n);
m = n;
for (int i = 1; i <= m; i++) scanf("%d%d", &a, &b), adde(a + 1, b + 1);
{
dfs0(1, 0);
for (int i = 1; i <= le; i++) {
vis[c[i == 1 ? le : i - 1]] = 1, vis[c[i == le ? 1 : i + 1]] = 1;
vis[c[i]] = 0;
ds[0] = -1;
mx2 = 0;
dfs2(c[i], 0);
lb[i] = ++ct2;
len[i] = mx2;
ct2 += mx2;
for (int j = 0; j <= mx2; j++)
sth[j + lb[i]] = s2[j], s5[j] += s2[j], s3[j] = s2[j], s2[j] = 0;
int l = 1;
while (l <= mx2 * 2) l <<= 1;
for (int j = mx2 + 1; j < l; j++) s3[j] = 0;
dft(l, s3, 1);
for (int j = 0; j < l; j++) s3[j] = 1ll * s3[j] * s3[j] % 998244353;
dft(l, s3, -1);
for (int j = 0; j < l; j++)
s4[j + le - 1] = (s4[j + le - 1] + s3[j]) % 998244353, s3[j] = 0;
dfs3(c[i]);
}
fz1(1, le);
fz2(1, le);
int l = 1;
while (l <= n * 2) l <<= 1;
dft(l, s5, 1);
for (int i = 0; i < l; i++) s5[i] = 1ll * s5[i] * s5[i] % 998244353;
dft(l, s5, -1);
for (int j = 0; j < l; j++)
s4[j + le - 1] = (s4[j + le - 1] - s5[j] + 998244353) % 998244353;
double ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + 1.0 * (s4[i] > 1e7 ? s4[i] - 998244353 : s4[i]) / (i + 1));
printf("%.10lf\n", ans + n);
}
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int head[5010];
int from[5010];
int to[100010];
int nex[100010];
int dep[5010];
int q[5010];
int cnt;
int vis[5010];
int bel[5010];
int num[100010];
double ans;
int tot;
int x, y, n, m;
int f[5010][17];
void add(int x, int y, int z) {
nex[++tot] = head[x];
head[x] = tot;
to[tot] = y;
num[tot] = z;
}
bool dfs(int x, int fa) {
vis[x] = 1;
for (int i = head[x]; i; i = nex[i]) {
if (num[i] != fa) {
if (vis[to[i]]) {
for (int j = x; j != to[i]; j = from[j]) {
q[++cnt] = j;
}
q[++cnt] = to[i];
return true;
} else {
from[to[i]] = x;
if (dfs(to[i], num[i])) {
return true;
}
}
}
}
return false;
}
void find(int x, int fa, int rt) {
bel[x] = rt;
dep[x] = dep[fa] + 1;
f[x][0] = fa;
for (int i = 1; i <= 15; i++) {
f[x][i] = f[f[x][i - 1]][i - 1];
}
for (int i = head[x]; i; i = nex[i]) {
if (to[i] != fa && !vis[to[i]]) {
find(to[i], x, rt);
}
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) {
swap(x, y);
}
int d = dep[x] - dep[y];
for (int i = 0; i <= 15; i++) {
if (d & (1 << i)) {
x = f[x][i];
}
}
if (x == y) {
return x;
}
for (int i = 15; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
}
}
return f[x][0];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++, y++;
add(x, y, i);
add(y, x, i);
}
dfs(1, 0);
memset(vis, 0, sizeof(vis));
if (cnt == 0) {
q[++cnt] = 1;
}
for (int i = 1; i <= cnt; i++) {
vis[q[i]] = 1;
}
for (int i = 1; i <= cnt; i++) {
find(q[i], 0, i);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (bel[i] == bel[j]) {
ans += (double)1 / (dep[i] + dep[j] - 2 * dep[lca(i, j)] + 1);
} else {
int X = dep[i] + dep[j];
int Y = abs(bel[i] - bel[j]) - 1;
int Z = cnt - Y - 2;
ans +=
(double)1 / (X + Y) + (double)1 / (X + Z) - (double)1 / (X + Y + Z);
}
}
}
printf("%.7f", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n, fa[N], dfn[N], ord, mark[N], len, vis[N];
vector<int> G[N];
void dfs(int u) {
dfn[u] = ++ord;
for (auto& v : G[u])
if (v ^ fa[u]) {
if (!dfn[v]) {
fa[v] = u;
dfs(v);
} else if (dfn[v] < dfn[u]) {
for (int p = u; p != fa[v]; p = fa[p]) mark[p] = 1, ++len;
}
}
}
double ans;
void dfs1(int u, int x, int y) {
vis[u] = 1;
++x;
if (!y)
ans += 1.0 / x;
else {
ans += 1.0 / x;
ans += 1.0 / (len - y - y + x);
ans -= 1.0 / (x + len - y - 1);
}
for (auto& v : G[u])
if (!vis[v]) dfs1(v, x, y + (mark[u] && mark[v]));
}
int main() {
scanf("%d", &n);
for (int i = 1, a, b; i <= n; i++) {
scanf("%d%d", &a, &b);
++a;
++b;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(1);
for (int i = 1; i <= n; i++) {
fill(vis, vis + 1 + n, 0);
dfs1(i, 0, 0);
}
printf("%.9f", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vec = vector<T>;
template <typename Iter>
ostream &_IterOutput_(ostream &o, Iter b, Iter e, const string ss = "",
const string se = "") {
o << ss;
for (auto it = b; it != e; it++) o << (it == b ? "" : ", ") << *it;
return o << se;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &o, const pair<T1, T2> &pair) {
return o << "(" << pair.first << ", " << pair.second << ")";
}
template <typename T>
ostream &operator<<(ostream &o, const vector<T> &vec) {
return _IterOutput_(o, begin(vec), end(vec), "[", "]");
}
template <typename T>
ostream &operator<<(ostream &o, const set<T> &st) {
return _IterOutput_(o, begin(st), end(st), "{", "}");
}
template <typename T, size_t N>
ostream &operator<<(ostream &o, const array<T, N> &arr) {
return _IterOutput_(o, begin(arr), end(arr), "|", "|");
}
template <typename T1, typename T2>
ostream &operator<<(ostream &o, const map<T1, T2> &mp) {
o << "{";
for (auto it = mp.begin(); it != mp.end(); it++) {
o << (it == mp.begin() ? "" : ", ") << it->first << ":" << it->second;
}
o << "}";
return o;
}
const int MX = 5555;
int N;
vector<int> el[MX];
bool ins[MX];
stack<int> st;
vector<int> lop;
bool dfs(int u, int fa) {
ins[u] = 1;
st.push(u);
for (auto v : el[u]) {
if (v == fa) continue;
if (ins[v]) {
int w;
do {
w = st.top();
st.pop();
lop.push_back(w);
} while (w != v);
return 1;
}
if (dfs(v, u)) return 1;
}
return 0;
}
bool islop[MX];
int lopId[MX];
int fath[MX];
vector<int> lopCh[MX];
double ans;
void dfs2(int u, int fa, int d, int id) {
lopCh[id].push_back(d);
fath[u] = id;
for (auto v : el[u]) {
if (v == fa) continue;
if (islop[v]) continue;
dfs2(v, u, d + 1, id);
}
}
void dfs3(int u, int fa, int d) {
ans += 1.0 / d;
for (auto v : el[u]) {
if (v == fa) continue;
if (islop[v] && v != fath[u]) {
continue;
}
dfs3(v, u, d + 1);
}
}
int32_t main() {
do {
ios_base::sync_with_stdio(0);
cin.tie(0);
} while (0);
cin >> N;
for (int i = 0; i < N; i++) {
int u, v;
cin >> u >> v;
el[u].push_back(v);
el[v].push_back(u);
}
dfs(0, -1);
assert(((int)(lop).size()));
int lll = 0;
for (auto v : lop) {
islop[v] = 1;
lopId[v] = ++lll;
}
for (auto v : lop) {
dfs2(v, -1, 1, v);
}
for (int i = 0; i < N; i++) {
dfs3(i, -1, 1);
}
for (auto u : lop) {
for (auto v : lop) {
if (u == v) continue;
int d1 = abs(lopId[u] - lopId[v]), d2 = lll - d1;
d1--;
d2--;
for (auto x : lopCh[u]) {
for (auto y : lopCh[v]) {
ans += 1.0 / (x + y + d1);
ans += 1.0 / (x + y + d2);
ans -= 1.0 / (x + y + d1 + d2);
}
}
}
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3000 + 10;
namespace opt {
int N;
const int alp = 999, MOD = 1004535809;
static int a[MAXN], b[MAXN], w[MAXN], tmp[MAXN];
int Pow(int a, int b) {
int d = 1;
for (; b; d = (b & 1) ? (long long)d * a % MOD : d,
a = (long long)a * a % MOD, b /= 2)
;
return d;
}
void FFT(int *a, int S, int d) {
if (d == N) return;
FFT(a, S, d << 1);
FFT(a, S + d, d << 1);
for (int i = S, j = S, p = 0; i < N / 2; i += d, j += d << 1, p += d) {
int G = a[j], K = a[j + d];
tmp[i] = ((long long)G + (long long)w[p] * K) % MOD;
tmp[i + N / 2] = ((long long)G + (long long)w[p + N / 2] * K) % MOD;
}
for (int i = S; i < N; i += d) a[i] = tmp[i];
}
void conv(int *aa, int *bb, int *c, int n) {
for (int i = 0; i < n; ++i) a[i] = aa[i], b[i] = bb[i];
if (n <= 5) {
for (int i = 0; i < n * 2; ++i) c[i] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) c[i + j] += a[i] * b[j];
for (int i = 0; i < n; ++i) a[i] = b[i] = 0;
return;
}
N = 1;
for (; N < n; N <<= 1)
;
N <<= 1;
w[0] = 1;
w[1] = alp;
for (int i = N; i <= (1 << 19); i <<= 1, w[1] = (long long)w[1] * w[1] % MOD)
;
for (int i = 2; i < N; ++i) w[i] = (long long)w[i - 1] * w[1] % MOD;
FFT(a, 0, 1);
FFT(b, 0, 1);
for (int i = 0; i < N; ++i) a[i] = (long long)a[i] * b[i] % MOD;
for (int i = 0; i < N; ++i) b[i] = a[i ? (N - i) : 0];
FFT(b, 0, 1);
int InvN = Pow(N, MOD - 2);
for (int i = 0; i < N; ++i)
c[i] = (long long)b[i] * InvN % MOD, a[i] = b[i] = 0;
}
} // namespace opt
vector<int> L;
struct Graph {
int id, next;
bool flag;
} g[MAXN * 2];
int st[MAXN], dep[MAXN], bel[MAXN], n, f[MAXN][MAXN], num[MAXN], fa[MAXN];
bool vis[MAXN];
void Add(int tot, int x, int y) {
g[tot].id = y, g[tot].next = st[x], st[x] = tot, g[tot].flag = true;
}
bool mark[MAXN];
int head, tail, que[MAXN], size[MAXN], h[MAXN];
void work(int x, int y) {
for (int i = x; i; i = fa[i]) mark[i] = true;
for (int i = y; i; i = fa[i]) {
L.push_back(i);
if (mark[i]) {
mark[i] = false;
break;
}
}
reverse(L.begin(), L.end());
for (int i = x; mark[i]; i = fa[i]) L.push_back(i);
}
void Find_Loop(int S) {
head = 0, tail = 1, que[1] = S;
fa[S] = 0;
vis[S] = true;
while (head < tail) {
int x = que[++head];
for (int i = st[x]; i != -1; i = g[i].next)
if (g[i].id != fa[x])
if (vis[g[i].id]) {
work(x, g[i].id);
return;
} else
vis[g[i].id] = true, fa[g[i].id] = x, que[++tail] = g[i].id;
}
}
void init() {
scanf("%d", &n);
memset(st, -1, sizeof(st));
for (int i = 1; i <= n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
++x, ++y;
Add(i * 2, x, y);
Add(i * 2 + 1, y, x);
}
Find_Loop(1);
memset(mark, 0, sizeof(mark));
for (int i = 0; i < (int)L.size(); ++i) mark[L[i]] = true;
for (int i = 0; i < (int)L.size(); ++i)
for (int j = st[L[i]]; j != -1; j = g[j].next)
if (mark[g[j].id]) g[j].flag = false;
memset(vis, 0, sizeof(vis));
}
double Tohka;
void BFS(int S) {
head = 0, tail = 1, que[1] = S;
dep[S] = 0;
vis[S] = true;
while (head < tail) {
int x = que[++head];
for (int i = st[x]; i != -1; i = g[i].next)
if (g[i].flag && !vis[g[i].id])
vis[g[i].id] = true, dep[g[i].id] = dep[x] + 1, que[++tail] = g[i].id;
}
for (int t = tail; t >= 1; --t) {
int x = que[t];
vis[x] = false;
size[x] = 1;
for (int i = st[x]; i != -1; i = g[i].next)
if (g[i].flag && !vis[g[i].id]) size[x] += size[g[i].id];
}
}
int Count(int x, int *f) {
BFS(x);
for (int i = 1; i <= tail; ++i) ++f[dep[que[i]]];
int Tohka = 0;
while (f[Tohka]) ++Tohka;
return Tohka;
}
int Find_G(int x) {
BFS(x);
for (int t = tail; t >= 1; --t) {
int x = que[t];
bool flag = true;
for (int i = st[x]; i != -1; i = g[i].next)
if (g[i].flag)
if (size[g[i].id] < size[x] && size[g[i].id] > tail / 2) flag = false;
if (flag && tail - size[x] <= tail / 2) return x;
}
}
int Kurumi;
int cnt[100];
void Calc(int *h, int n, int delta, int p, bool flag) {
for (int i = 0; i < n; ++i)
Tohka += (double)p * 1.0 / (i + delta) * h[i] * Kurumi,
h[i] = (!flag) ? 0 : h[i];
}
void solve(int dep, int x, int n) {
int G = Find_G(x);
int len = Count(G, h);
opt::conv(h, h, h, len);
Calc(h, len * 2, 1, 1, 0);
for (int i = st[G]; i != -1; i = g[i].next)
if (g[i].flag) {
g[i].flag = g[i ^ 1].flag = false;
len = Count(g[i].id, h);
opt::conv(h, h, h, len);
Calc(h, len * 2, 3, -1, 0);
solve(dep + 1, g[i].id, size[g[i].id]);
}
}
void solve() {
Kurumi = 1;
for (int i = 0; i < (int)L.size(); ++i) {
num[i] = Count(L[i], f[i]);
solve(0, L[i], size[L[i]]);
}
Kurumi = 2;
for (int i = 0; i < (int)L.size(); ++i)
for (int j = i + 1; j < (int)L.size(); ++j) {
int y = j - i - 1, z = (i - j + (int)L.size()) - 1;
opt::conv(f[i], f[j], h, max(num[i], num[j]));
int len = max(num[i], num[j]) * 2;
Calc(h, len, y + 2, 1, 1);
Calc(h, len, z + 2, 1, 1);
Calc(h, len, y + z + 2, -1, 0);
}
printf("%.10lf\n", Tohka);
}
int main() {
init();
solve();
fclose(stdin);
fclose(stdout);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
const int MAXN = 3005, MAXLOG = 15;
template <typename _T>
void read(_T &x) {
x = 0;
char s = getchar();
int f = 1;
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s - '0'), s = getchar();
}
x *= f;
}
template <typename _T>
void write(_T x) {
if (x < 0) {
putchar('-');
x = (~x) + 1;
}
if (9 < x) {
write(x / 10);
}
putchar(x % 10 + '0');
}
template <typename _T>
_T ABS(const _T a) {
return a < 0 ? -a : a;
}
struct edge {
int to, nxt;
} Graph[MAXN << 1];
int f[MAXN][MAXLOG];
int sta[MAXN], top;
int cir[MAXN];
int head[MAXN], dep[MAXN], col[MAXN];
int N, lg2, cnt, siz;
bool inSta[MAXN], onCir[MAXN];
void balance(int &u, const int steps) {
for (int i = 0; (1 << i) <= steps; i++)
if (steps & (1 << i)) u = f[u][i];
}
void addEdge(const int from, const int to) {
Graph[++cnt].to = to, Graph[cnt].nxt = head[from];
head[from] = cnt;
}
bool findCircle(const int u, const int fr) {
if (inSta[u]) {
int v;
do onCir[cir[++siz] = v = sta[top--]] = true;
while (v ^ u);
return true;
}
inSta[sta[++top] = u] = true;
for (int i = head[u], v; i; i = Graph[i].nxt) {
v = Graph[i].to;
if (v ^ fr && findCircle(v, u)) return true;
}
inSta[sta[top--]] = false;
return false;
}
void DFS(const int u, const int fa, const int c) {
col[u] = c, f[u][0] = fa, dep[u] = dep[fa] + 1;
for (int i = head[u], v; i; i = Graph[i].nxt)
if ((v = Graph[i].to) ^ fa && !onCir[v]) DFS(v, u, c);
}
void init() {
lg2 = log2(N);
for (int j = 1; j <= lg2; j++)
for (int i = 1; i <= N; i++) f[i][j] = f[f[i][j - 1]][j - 1];
}
int LCA(int u, int v) {
if (dep[u] > dep[v]) balance(u, dep[u] - dep[v]);
if (dep[v] > dep[u]) balance(v, dep[v] - dep[u]);
if (u == v) return u;
for (int i = lg2; ~i; i--)
if (f[u][i] ^ f[v][i]) u = f[u][i], v = f[v][i];
return f[u][0];
}
int dist(const int u, const int v) {
return dep[u] + dep[v] - 2 * dep[LCA(u, v)] + 1;
}
int main() {
read(N);
for (int i = 1, fr, to; i <= N; i++)
read(fr), read(to), fr++, to++, addEdge(fr, to), addEdge(to, fr);
findCircle(1, 0);
for (int i = 1; i <= siz; i++) DFS(cir[i], 0, i);
init();
double ans = 0;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) {
if (col[i] == col[j])
ans += 1.0 / dist(i, j);
else {
int lin = dep[i] + dep[j], lef = ABS(col[i] - col[j]) - 1,
rig = siz - 2 - lef;
ans += 1.0 / (lin + lef) + 1.0 / (lin + rig) - 1.0 / (lin + lef + rig);
}
}
printf("%.15lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3010;
const int MAXE = MAXN << 1;
int N;
int e[MAXE], enxt[MAXE], head[MAXN], ec;
void regi(int u, int v) {
e[++ec] = v;
enxt[ec] = head[u];
head[u] = ec;
}
int visId[MAXN];
vector<int> Loop, stk;
bool FindLoop(int ths, int prev) {
if (visId[ths] != -1) {
Loop = vector<int>(stk.begin() + visId[ths], stk.end());
return true;
}
visId[ths] = stk.size();
stk.push_back(ths);
bool Flag = false;
for (int E = head[ths]; E; E = enxt[E])
if ((prev != e[E]) && (FindLoop(e[E], ths))) {
Flag = true;
break;
}
stk.pop_back();
visId[ths] = -1;
return Flag;
}
int Dist[MAXN], Color[MAXN], Father[MAXN], LoopAddress[MAXN];
int Ance[MAXN][13];
void dfs(int cur, int color, int dist, int father) {
Dist[cur] = dist;
Color[cur] = color;
Father[cur] = father;
Ance[cur][0] = father;
for (int i = 1; i <= 12; i++) Ance[cur][i] = Ance[Ance[cur][i - 1]][i - 1];
for (int E = head[cur]; E; E = enxt[E])
if (Dist[e[E]] > dist + 1) dfs(e[E], color, dist + 1, cur);
}
int lca(int u, int v) {
if (Dist[u] > Dist[v]) swap(u, v);
while (Dist[u] != Dist[v]) v = Ance[v][__builtin_ctz(Dist[v] - Dist[u])];
if (u == v) return u;
for (int lv = 31 - __builtin_clz(Dist[u]); lv >= 0; lv--)
if (Ance[u][lv] != Ance[v][lv]) {
u = Ance[u][lv];
v = Ance[v][lv];
}
return Father[u];
}
void MakeDistance() {
int i;
for (i = 0; i <= 12; i++) Ance[0][i] = 0;
for (i = 1; i <= N; i++) Dist[i] = 2333333;
for (vector<int>::iterator it = Loop.begin(); it != Loop.end(); it++)
Dist[*it] = 0;
for (vector<int>::iterator it = Loop.begin(); it != Loop.end(); it++)
dfs(*it, *it, 0, 0);
}
int main() {
scanf("%d", &N);
int i, j;
for (i = 1; i <= N; i++) head[i] = 0;
ec = 0;
for (i = 1; i <= N; i++) {
int u, v;
scanf("%d%d", &u, &v);
regi(u + 1, v + 1);
regi(v + 1, u + 1);
}
for (i = 1; i <= N; i++) visId[i] = -1;
stk.clear();
FindLoop(1, 0);
for (i = 1; i <= N; i++) LoopAddress[i] = -1;
for (i = 0; i <= Loop.size() - 1; i++) LoopAddress[Loop[i]] = i;
MakeDistance();
double Ans = 0;
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++)
if (Color[i] == Color[j])
Ans += 1.0 / (Dist[i] + Dist[j] - 2 * Dist[lca(i, j)] + 1);
else {
int MS, B1, B2;
MS = Dist[i] + Dist[j] + 2;
B1 = abs(LoopAddress[Color[i]] - LoopAddress[Color[j]]) - 1;
B2 = Loop.size() - 2 - B1;
Ans += 1.0 / (MS + B1);
Ans += 1.0 / (MS + B2);
Ans -= 1.0 / (MS + B1 + B2);
}
printf("%.14f\n", Ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long Inf = 1e10;
const int N = 100005;
const int P = 1000000007;
int IN() {
int x = 0;
int f = 0, ch = 0;
for ((ch = getchar()); ch < 48 || ch > 57; (ch = getchar())) f = (ch == '-');
for (; ch >= 48 && ch <= 57; (ch = getchar()))
x = (x << 1) + (x << 3) + ch - 48;
return f ? (-x) : x;
}
int Pow(int x, int y, int p) {
int A = 1;
for (; y; y >>= 1, x = (long long)x * x % p)
if (y & 1) A = (long long)A * x % p;
return A;
}
int n, F[N], eu, ev, dep[N], B[N];
struct edge {
int v, pre;
} e[N];
int dex, adj[N];
int sz;
int get(int x) {
if (F[x] == x) return x;
return F[x] = get(F[x]);
}
int fa[20][3005];
void DFS2(int x, int f) {
for (int i = adj[x]; i; i = e[i].pre) {
int v = e[i].v;
if (B[v] == v) continue;
if (v == f) continue;
B[v] = B[x];
dep[v] = dep[x] + 1;
fa[0][v] = x;
for (int i = (int)1; i <= (int)16; i++) fa[i][v] = fa[i - 1][fa[i - 1][v]];
DFS2(v, x);
}
}
int lab[N], Q[N], r, vis[N], Pre[N], tot;
void BFS(int x) {
memset(vis, 0, sizeof vis);
vis[Q[r = 1] = x] = 1;
for (int i = (int)1; i <= (int)r; i++) {
int u = Q[i];
for (int i = adj[u]; i; i = e[i].pre) {
int v = e[i].v;
if (vis[v]) continue;
Pre[v] = u;
if (!vis[v]) vis[Q[++r] = v] = 1;
}
}
for (int i = ev; i; i = Pre[i]) {
B[i] = i;
lab[i] = ++tot;
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 11; i >= 0; i--)
if (dep[fa[i][x]] >= dep[y]) x = fa[i][x];
for (int i = 11; i >= 0; i--)
if (fa[i][x] ^ fa[i][y]) x = fa[i][x], y = fa[i][y];
return (x == y) ? (x) : (fa[0][x]);
}
int main() {
scanf("%d", &n);
for (int i = (int)1; i <= (int)n; i++) F[i] = i;
for (int i = (int)1; i <= (int)n; i++) {
int u = IN() + 1, v = IN() + 1;
int ux = get(u), vx = get(v);
if (ux == vx) {
eu = u, ev = v;
continue;
}
e[++dex] = (edge){v, adj[u]};
adj[u] = dex;
e[++dex] = (edge){u, adj[v]};
adj[v] = dex;
F[ux] = vx;
}
BFS(eu);
memset(dep, 0, sizeof dep);
for (int i = (int)1; i <= (int)n; i++)
if (B[i] == i) {
dep[i] = 1;
DFS2(i, 0);
}
double ans = 0;
for (int i = (int)1; i <= (int)n; i++)
for (int j = (int)1; j <= (int)n; j++) {
if (B[i] == B[j]) {
ans += 1. / (dep[i] + dep[j] - 2 * dep[lca(i, j)] + 1);
} else {
int X = lab[B[i]], Y = lab[B[j]];
int u = dep[i] - 1, v = dep[j] - 1;
if (X < Y) swap(X, Y);
ans += 1. / (u + v + X - Y + 1);
ans += 1. / (u + v + Y + tot - X + 1);
ans -= 1. / (u + v + tot);
}
}
printf("%.10f\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
struct E {
int to, next;
} mem[N << 1];
int n, x, y, num, h, t, c;
double ans;
int head[N], d1[N], d2[N], q[N];
bool vis[N];
void add(int x, int y) {
num++;
mem[num].to = y;
mem[num].next = head[x];
head[x] = num;
}
void init() {
int k, u;
for (int i = 1; i <= n; i++)
if (d1[i] == 1) q[++t] = i;
while (h < t) {
k = q[++h];
for (int j = head[k]; j; j = mem[j].next) {
u = mem[j].to;
d1[u]--;
if (d1[u] == 1) q[++t] = u;
}
}
c = n - t;
}
void dfs(int k) {
int u;
vis[k] = 1;
for (int j = head[k]; j; j = mem[j].next) {
u = mem[j].to;
if (vis[u]) continue;
d1[u] = d1[k] + 1;
if (!d2[u]) {
d2[u] = d2[k] + 1;
ans += 1.0 / d2[u];
} else
ans += 1.0 / d1[u] - 2.0 / (d1[u] + d2[u] + c - 2);
dfs(u);
}
vis[k] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++;
y++;
add(x, y);
add(y, x);
d1[x]++;
d1[y]++;
}
init();
for (int i = 1; i <= n; i++) {
memset(d1, 0, sizeof(d1));
memset(d2, 0, sizeof(d2));
memset(vis, 0, sizeof(vis));
d1[i] = d2[i] = 1;
dfs(i);
}
printf("%.6f\n", ans + n);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vec = vector<T>;
template <typename Iter>
ostream &_IterOutput_(ostream &o, Iter b, Iter e, const string ss = "",
const string se = "") {
o << ss;
for (auto it = b; it != e; it++) o << (it == b ? "" : ", ") << *it;
return o << se;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &o, const pair<T1, T2> &pair) {
return o << "(" << pair.first << ", " << pair.second << ")";
}
template <typename T>
ostream &operator<<(ostream &o, const vector<T> &vec) {
return _IterOutput_(o, begin(vec), end(vec), "[", "]");
}
template <typename T>
ostream &operator<<(ostream &o, const set<T> &st) {
return _IterOutput_(o, begin(st), end(st), "{", "}");
}
template <typename T, size_t N>
ostream &operator<<(ostream &o, const array<T, N> &arr) {
return _IterOutput_(o, begin(arr), end(arr), "|", "|");
}
template <typename T1, typename T2>
ostream &operator<<(ostream &o, const map<T1, T2> &mp) {
o << "{";
for (auto it = mp.begin(); it != mp.end(); it++) {
o << (it == mp.begin() ? "" : ", ") << it->first << ":" << it->second;
}
o << "}";
return o;
}
const int MX = 5555;
int N;
vector<int> el[MX];
bool ins[MX];
stack<int> st;
vector<int> lop;
bool dfs(int u, int fa) {
ins[u] = 1;
st.push(u);
for (auto v : el[u]) {
if (v == fa) continue;
if (ins[v]) {
int w;
do {
w = st.top();
st.pop();
lop.push_back(w);
} while (w != v);
return 1;
}
if (dfs(v, u)) return 1;
}
return 0;
}
bool islop[MX];
int lopId[MX];
int fath[MX];
vector<int> lopCh[MX];
double ans;
void dfs2(int u, int fa, int d, int id) {
lopCh[id].push_back(d);
fath[u] = id;
for (auto v : el[u]) {
if (v == fa) continue;
if (islop[v]) continue;
dfs2(v, u, d + 1, id);
}
}
void dfs3(int u, int fa, int d) {
ans += 1.0 / d;
for (auto v : el[u]) {
if (v == fa) continue;
if (islop[v] && v != fath[u]) {
continue;
}
dfs3(v, u, d + 1);
}
}
int32_t main() {
do {
ios_base::sync_with_stdio(0);
cin.tie(0);
} while (0);
cin >> N;
for (int i = 0; i < N; i++) {
int u, v;
cin >> u >> v;
el[u].push_back(v);
el[v].push_back(u);
}
dfs(0, -1);
assert(((int)(lop).size()));
int lll = 0;
for (auto v : lop) {
islop[v] = 1;
lopId[v] = ++lll;
}
for (auto v : lop) {
dfs2(v, -1, 1, v);
}
for (int i = 0; i < N; i++) {
dfs3(i, -1, 1);
}
for (auto u : lop) {
for (auto v : lop) {
if (u == v) continue;
int d1 = abs(lopId[u] - lopId[v]), d2 = lll - d1;
d1--;
d2--;
for (auto x : lopCh[u]) {
for (auto y : lopCh[v]) {
ans += 1.0 / (x + y + d1);
ans += 1.0 / (x + y + d2);
ans -= 1.0 / (x + y + d1 + d2);
}
}
}
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4011;
namespace RikukiIX {
int n;
int xi, yi;
struct sumireko {
int to, ne;
} e[N << 1];
int he[N], ecnt;
void addline(int f, int t) {
e[++ecnt].to = t;
e[ecnt].ne = he[f];
he[f] = ecnt;
}
int sta[N], stp;
int vis[N];
int sp;
int onr[N], rnd[N], ra;
int dis[N];
double ans;
int rt;
int bl[N];
void fr(int x, int f) {
sta[++stp] = x, vis[x] = 1;
for (int i = he[x], t = e[i].to; i; i = e[i].ne, t = e[i].to) {
if (t == f) continue;
if (vis[t]) {
if (!sp) {
sp = t;
int g = 0;
while (g != sp) {
g = sta[stp--];
rnd[++ra] = g, onr[g] = ra;
}
}
} else
fr(t, x);
}
if (sta[stp] == x) sta[stp--] = 0;
}
void dfs(int x, int f, int r) {
bl[x] = r;
for (int i = he[x], t = e[i].to; i; i = e[i].ne, t = e[i].to) {
if (t == f || onr[t]) continue;
dis[t] = dis[x] + 1;
dfs(t, x, r);
}
}
void work(int x, int dep) {
vis[x] = 1;
if (x != rt) {
if (bl[x] == bl[rt])
ans += (long double)1.0 / (double)dep;
else {
double a = dis[rt] + dis[x], b = abs(onr[bl[x]] - onr[bl[rt]]) - 1,
c = ra - 2 - b;
ans += (long double)1.0 / (a + b) + 1.0 / (a + c) - 1.0 / (a + b + c);
}
}
for (int i = he[x], t = e[i].to; i; i = e[i].ne, t = e[i].to) {
if (!vis[t]) work(t, dep + 1);
}
}
int mian() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &xi, &yi), xi++, yi++, addline(xi, yi), addline(yi, xi);
fr(1, 0);
for (int i = 1; i <= ra; i++) {
int x = rnd[i];
dis[x] = 1;
dfs(x, 0, x);
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
rt = i, work(i, 1);
}
ans += n;
printf("%.10lf\n", ans);
return 0;
}
} // namespace RikukiIX
int main() { return RikukiIX::mian(); }
| 10 |
CPP
|
#include <bits/stdc++.h>
const int sz = 3010;
int vi[sz], low[sz], t;
int sta[sz], top = 0;
int con[sz], cir[sz];
std::vector<int> edge[sz], ed[sz];
void dfs(int x, int p) {
vi[x] = low[x] = ++t;
sta[top++] = x;
for (int k = 0; k < edge[x].size(); k++) {
int y = edge[x][k];
if (!vi[y]) dfs(y, x);
if (y != p) low[x] = std::min(low[x], low[y]);
}
if (vi[x] == low[x]) {
int y;
do {
y = sta[--top];
con[y] = x;
} while (x != y);
}
return;
}
bool in[sz];
int fi[sz], d[sz], dd[sz], cd[sz], fa[sz];
void DFS(int x, int ff) {
vi[x] = 1;
fa[x] = ff;
for (int k = 0; k < edge[x].size(); k++) {
int y = edge[x][k];
if (in[y] || vi[y]) continue;
vi[y] = 1;
d[y] = d[x] + 1;
DFS(y, ff);
}
return;
}
void cir_dfs(int x) {
vi[x] = 1;
for (int k = 0; k < edge[x].size(); k++) {
int y = edge[x][k];
if ((!in[y]) || vi[y]) continue;
cd[y] = cd[x] + 1;
cir_dfs(y);
}
return;
}
double ans;
void find_dfs(int x) {
vi[x] = 1;
ans += 1 / (double)(dd[x] + 1);
for (int k = 0; k < edge[x].size(); k++) {
int y = edge[x][k];
if (vi[y] || fa[x] != fa[y]) continue;
dd[y] = dd[x] + 1;
find_dfs(y);
}
return;
}
int main() {
int n, k, a, b, num = 0, cir, i;
scanf("%d", &n);
for (k = 1; k <= n; k++) {
scanf("%d%d", &a, &b);
edge[a].push_back(b);
edge[b].push_back(a);
}
dfs(0, 0);
for (k = 0; k < n; k++) fi[con[k]]++;
for (k = 0; k < n; k++) {
if (fi[k] > 1) {
cir = k;
break;
}
}
memset(vi, 0, sizeof(vi));
for (k = 0; k < n; k++) {
if (con[k] == cir) {
in[k] = 1;
num++;
}
}
cir_dfs(cir);
for (k = 0; k < n; k++) {
if (con[k] == cir) {
DFS(k, k);
}
}
ans = 0;
for (k = 0; k < n; k++) {
memset(vi, 0, sizeof(vi));
for (i = 0; i < n; i++) {
if (fa[k] == fa[i]) continue;
int c1, c2, d1, d2;
d1 = d[k] + 1;
d2 = d[i] + 1;
c1 = abs(cd[fa[k]] - cd[fa[i]]) - 1;
c2 = num - c1 - 2;
int q = c1 + c2 + d1 + d2;
ans += 1 / (double)q + (double)c1 / (double)q / (double)(q - c1) +
(double)c2 / (double)q / (double)(q - c2);
}
dd[k] = 0;
find_dfs(k);
}
printf("%.9f\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
vector<int> E[3005];
int deg[3005], V[3005];
int sz;
double ans;
void dfs(int r, int i, int A, int B) {
deg[i] == 2 ? ++B : ++A;
V[i] = r;
if (B == sz)
ans += 1.0 / (A + 2);
else if (B <= 2)
ans += 1.0 / (A + B);
else
ans += 1.0 / (A + B) + 1.0 / (A + sz - B + 2) - 1.0 / (A + sz);
for (auto x : E[i])
if (V[x] != r) dfs(r, x, A, B);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0, a, b; i < n; ++i)
cin >> a >> b, E[a].push_back(b), E[b].push_back(a), ++deg[a], ++deg[b];
queue<int> Q;
for (int i = 0; i < n; ++i)
if (deg[i] == 1) Q.push(i);
while (!Q.empty()) {
auto x = Q.front();
Q.pop();
for (auto y : E[x]) {
--deg[y];
if (deg[y] == 1) Q.push(y);
}
}
for (int i = 0; i < n; ++i)
if (deg[i] == 2) ++sz;
fill(V, V + n, -1);
for (int i = 0; i < n; ++i) dfs(i, i, 0, 0);
cout << fixed;
cout.precision(10);
cout << ans << endl;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, m, flag, sum, tot, dis[3001][3001], e[100001], nt[100001], hd[100001],
pa[100001], v[3001], d[3001], f[3001], sz[3001];
double ans;
void build(int x, int y) {
tot++;
e[tot] = y;
nt[tot] = hd[x];
hd[x] = tot;
}
void dfs(int x, int fa) {
int i, y;
if (v[x]) {
y = fa;
d[x] = 1;
sum = 1;
while (y != x) {
sum++;
d[y] = sum;
y = pa[y];
}
flag = 1;
return;
}
v[x] = 1;
for (i = hd[x]; i; i = nt[i]) {
if (e[i] == fa) continue;
pa[e[i]] = x;
dfs(e[i], x);
if (flag) return;
}
}
void get(int x, int len, int fa) {
int i;
if (d[x] && !flag) {
flag = 1;
sz[fa] = len;
f[fa] = d[x];
}
v[x] = 1;
dis[fa][x] = len;
for (i = hd[x]; i; i = nt[i]) {
if (v[e[i]]) continue;
get(e[i], len + 1, fa);
}
}
int main() {
int i, j, x, y;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++;
y++;
build(x, y);
build(y, x);
}
dfs(1, 0);
for (i = 1; i <= n; i++) {
flag = 0;
memset(v, 0, sizeof(v));
get(i, 1, i);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j)
ans += 1;
else if (f[i] == f[j])
ans += 1 / (1.0 * abs(dis[i][j]));
else {
x = abs(f[i] - f[j]) - 1;
y = sum - 2 - x;
ans += 1.0 / (sz[i] + sz[j] + x) + 1.0 / (sz[i] + sz[j] + y) -
1.0 / (sz[i] + sz[j] + x + y);
}
}
}
printf("%.10lf", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int q[N];
int fa[N], dep[N];
int n, co[N], dis[N];
vector<int> e[N];
double ans;
void dfs(int x) {
for (auto i : e[x])
if (i != fa[x]) {
if (!dep[i]) {
fa[i] = x;
dep[i] = dep[x] + 1;
dfs(i);
} else if (dep[i] < dep[x]) {
for (int y = x;; y = fa[y]) {
q[++*q] = y;
if (y == i) break;
}
}
}
}
void find(int x) {
for (auto i : e[x])
if (!co[i]) {
co[i] = co[x];
dep[i] = dep[x] + 1;
find(i);
}
}
void SSSP(int x) {
for (int i = (int)(1); i <= (int)(n); i++) dis[i] = -1;
int h = 0, t = 1;
q[1] = x;
dis[x] = 0;
while (h != t) {
int x = q[++h];
for (auto i : e[x])
if (dis[i] == -1 && co[i] == co[x]) {
dis[i] = dis[x] + 1;
q[++t] = i;
}
}
}
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); i++) {
int x, y;
scanf("%d%d", &x, &y);
e[++x].push_back(++y);
e[y].push_back(x);
}
dfs(1);
for (int i = (int)(1); i <= (int)(*q); i++) co[q[i]] = i, dep[q[i]] = 0;
for (int i = (int)(1); i <= (int)(*q); i++) find(q[i]);
for (int i = (int)(1); i <= (int)(n); i++) {
SSSP(i);
for (int j = (int)(i + 1); j <= (int)(n); j++)
if (co[i] == co[j])
ans += 2.0 / (dis[j] + 1);
else {
int d1 = dep[i] + dep[j];
int d2 = (co[i] + (*q) - co[j]) % (*q);
int d3 = *q - d2;
ans += 2.0 / (d1 + d2 + 1);
ans += 2.0 / (d1 + d3 + 1);
ans -= 2.0 / (d1 + (*q));
}
}
printf("%.10lf\n", ans + n);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void judge() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
int head[maxn], ne[maxn << 1], t[maxn << 1], S[maxn], top, cycle, num, n,
belong[maxn], dis[maxn];
bool ins[maxn], ok, oncy[maxn];
double ans = 0;
inline void addedge(int x, int y) {
ne[++num] = head[x];
head[x] = num;
t[num] = y;
}
inline void findcycle(int u, int fa) {
S[++top] = u;
ins[u] = 1;
for (int i = head[u]; i != -1; i = ne[i])
if (t[i] != fa) {
if (ok) return;
if (ins[t[i]]) {
while (S[top] != t[i]) oncy[S[top--]] = 1, cycle++;
cycle++;
oncy[t[i]] = 1;
ok = 1;
return;
}
findcycle(t[i], u);
}
top--;
}
inline void dfs_find(int u, int fa, int rt, int d) {
belong[u] = rt;
dis[u] = d;
for (int i = head[u]; i != -1; i = ne[i])
if (t[i] != fa && !oncy[t[i]]) dfs_find(t[i], u, rt, d + 1);
}
int p, first;
inline void dfs_ans(int u, int fa, int d) {
if (u == belong[p]) {
if (first) return;
first += 1;
}
ans += 1.0 / (d + 1);
for (int i = head[u]; i != -1; i = ne[i])
if (t[i] != fa) {
dfs_ans(t[i], u, d + 1);
}
}
int main() {
read(n);
for (int i = (1); i <= (n); i++) head[i] = -1;
for (int i = (1); i <= (n); i++) {
int a, b;
read(a);
read(b);
a++;
b++;
addedge(a, b);
addedge(b, a);
}
findcycle(1, -1);
for (int i = (1); i <= (n); i++)
if (oncy[i]) dfs_find(i, -1, i, 0);
for (int i = (1); i <= (n); i++) p = i, first = 0, dfs_ans(i, -1, 0);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
if (belong[i] != belong[j]) ans -= 1.0 / (dis[i] + dis[j] + cycle);
printf("%.23lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
int N, C, cnt, d[maxn], q[maxn], head[maxn], d1[maxn], d2[maxn];
double ans;
struct Data {
int next, to;
} data[maxn << 1];
bool vis[maxn];
void add(int x, int y) {
data[++cnt] = (Data){head[x], y};
head[x] = cnt;
}
void dfs(int x) {
vis[x] = 1;
for (int i = head[x]; i; i = data[i].next) {
Data &e = data[i];
if (vis[e.to]) continue;
d2[e.to] = d2[x] + 1;
if (!d1[e.to])
d1[e.to] = d1[x] + 1, ans += 1.0 / d1[e.to];
else
ans += 1.0 / d2[e.to] - 2.0 / (d1[e.to] + d2[e.to] + C - 2);
dfs(e.to);
}
vis[x] = 0;
}
int main() {
scanf("%d", &N);
for (int i = 1, u, v; i <= N; ++i)
scanf("%d%d", &u, &v), ++u, ++v, ++d[u], ++d[v], add(u, v), add(v, u);
int h = 1, t = 0;
for (int i = 1; i <= N; ++i)
if (d[i] == 1) q[++t] = i;
while (h <= t)
for (int i = head[q[h++]]; i; i = data[i].next)
if ((--d[data[i].to]) == 1) q[++t] = data[i].to;
C = N - t;
for (int i = 1; i <= N; ++i) {
memset(d1, 0, sizeof(d1));
memset(d2, 0, sizeof(d2));
d1[i] = d2[i] = 1, dfs(i);
}
printf("%.10lf\n", ans + N);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (f) x = -x;
}
template <typename F>
inline void write(F x, char ed = '\n') {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar('0' | st[tp--]);
putchar(ed);
}
template <typename T>
inline void Mx(T &x, T y) {
x < y && (x = y);
}
template <typename T>
inline void Mn(T &x, T y) {
x > y && (x = y);
}
const int N = 3050;
vector<int> vec;
int To[N], h[N], to[N << 1], ne[N << 1], vis[N], tot, rt, m, n;
inline void add(int x, int y) { ne[++tot] = h[x], to[h[x] = tot] = y; }
void gethua(int x, int fa) {
vis[x] = 1;
for (int i = h[x]; i; i = ne[i]) {
int y = to[i];
if (y == fa) continue;
if (rt != -1) return;
To[x] = y;
if (vis[y]) {
rt = x, vec.push_back(x);
for (int t = y; t != x; t = To[t]) vec.push_back(t);
return;
}
gethua(y, x);
}
}
double ans;
void dfs2(int x, int fa, int X, int Y, int Z) {
ans = ans + 1.0 / (X + Y) + 1.0 / (X + Z) - 1.0 / (X + Y + Z);
for (int i = h[x]; i; i = ne[i])
if (vis[to[i]] == -1 && to[i] != fa) dfs2(to[i], x, X + 1, Y, Z);
}
int jue(int x) { return x > 0 ? x : -x; }
void dfs(int x, int fa, int X) {
ans = ans + 1.0 / X;
if (~vis[x]) {
int sz = vec.size();
for (int i = 0; i < sz; i++) {
if (vec[i] == x) continue;
dfs2(vec[i], x, X + 1, jue(i - vis[x]) - 1, sz - jue(i - vis[x]) - 1);
}
for (int i = h[x]; i; i = ne[i])
if (vis[to[i]] == -1 && to[i] != fa) dfs(to[i], x, X + 1);
return;
}
for (int i = h[x]; i; i = ne[i])
if (to[i] != fa) dfs(to[i], x, X + 1);
}
int main() {
read(n);
rt = -1;
for (int i = 1, x, y; i <= n; i++) read(x), read(y), add(x, y), add(y, x);
gethua(0, -1);
memset(vis, -1, sizeof(vis));
for (int i = 0; i < (int)vec.size(); i++) vis[vec[i]] = i;
for (int i = 0; i < n; i++) dfs(i, -1, 1);
printf("%.10lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[3005];
bool vis[3005], cir[3005];
int q, s, n;
int Find_Cir(int x, int y) {
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++)
if (!vis[v[x][i]]) {
int t = Find_Cir(v[x][i], x);
if (t) {
if (t > 0) {
cir[x] = 1;
s++;
}
return t == x ? -1 : t;
}
} else if (v[x][i] != y) {
cir[x] = s = 1;
return v[x][i];
}
}
double ans;
void Dfs(int x) {
vis[x] = 1;
q += cir[x];
n++;
if (q > 1) {
int c = n - q + s, a = q - 2, b = s - q;
ans += (double)a / c / (c - a) + (double)b / c / (c - b) + 1.0 / c;
} else
ans += 1.0 / n;
for (int i = 0; i < v[x].size(); i++)
if (!vis[v[x][i]]) Dfs(v[x][i]);
n--;
q -= cir[x];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1, x, y; i <= n; i++)
scanf("%d%d", &x, &y), v[x + 1].push_back(y + 1), v[y + 1].push_back(x + 1);
Find_Cir(1, 0);
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
Dfs(i);
}
printf("%.20lf\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int hed[3005], to[3005 << 1], nxt[3005 << 1], q[3005], cnt, tot;
bool in[3005], used[3005];
int n, deg[3005], C;
double ans;
void ins(int x, int y) {
nxt[++tot] = hed[x];
to[tot] = y;
hed[x] = tot;
}
void dfs(int x, int len, int lcn) {
used[x] = 1;
if (lcn <= 1)
ans += 1.0 / len;
else
ans += 1.0 / len + 1.0 / (len - 2 * lcn + C + 2) - 1.0 / (len + C - lcn);
for (int i = hed[x]; i; i = nxt[i])
if (!used[to[i]]) dfs(to[i], len + 1, lcn + in[to[i]]);
}
int main() {
scanf("%d", &n);
for (int u, v, i = 1; i <= n; ++i) {
scanf("%d%d", &u, &v);
ins(u, v);
ins(v, u);
++deg[u];
++deg[v];
}
for (int i = 0; i < n; ++i)
if (deg[i] == 1) q[++cnt] = i;
for (int x = 1; x <= cnt; ++x)
for (int i = hed[q[x]]; i; i = nxt[i])
if ((--deg[to[i]]) == 1) q[++cnt] = to[i];
for (int i = 0; i < n; ++i)
if (deg[i] > 1) in[i] = 1;
C = n - cnt;
for (int i = 0; i < n; ++i) {
memset(used, 0, sizeof(used));
dfs(i, 1, in[i]);
}
printf("%.8lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int N = 3005;
int n, top, root, tot;
struct Edge {
int to;
Edge *nxt;
Edge(int to = 0, Edge *nxt = NULL) : to(to), nxt(nxt) {}
} * head[N], pool[N << 1], *tail = pool;
inline void add(int u, int v) { head[u] = new (tail++) Edge(v, head[u]); }
bool vis[N];
int st[N], pos[N], dep[N], anc[N], fa[N][13];
bool flag;
void find_circle(int x, int fa) {
vis[x] = 1;
st[++top] = x;
for (Edge *i = head[x]; i; i = i->nxt) {
int to = i->to;
if (to == fa) continue;
if (vis[to]) return (void)(root = to, flag = 1);
find_circle(to, x);
if (flag) return;
}
vis[x] = 0;
top--;
}
void get(int x, int rot) {
anc[x] = rot;
dep[x] = dep[fa[x][0]] + 1;
for (int i = 1; i <= 12; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (Edge *i = head[x]; i; i = i->nxt) {
int to = i->to;
if (to == fa[x][0] || pos[to]) continue;
fa[to][0] = x;
get(to, rot);
}
}
inline int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 12; i >= 0; i--)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 12; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
inline int dis(int x, int y) {
return dep[x] + dep[y] - (dep[LCA(x, y)] << 1) + 1;
}
int main() {
n = read();
double ans = 0;
for (int i = 1, u, v; i <= n; i++)
u = read() + 1, v = read() + 1, add(u, v), add(v, u);
find_circle(1, 0);
pos[root] = ++tot;
while (st[top] != root) pos[st[top--]] = ++tot;
for (int i = 1; i <= n; i++)
if (pos[i]) get(i, i);
for (int i = 1, x, y, z; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (anc[i] != anc[j]) {
x = dep[i] - dep[anc[i]] + dep[j] - dep[anc[j]] + 2;
y = (pos[anc[i]] - pos[anc[j]] - 1 + tot) % tot;
z = (pos[anc[j]] - pos[anc[i]] - 1 + tot) % tot;
ans += 1.0 / (double)(x + y) + 1.0 / (double)(x + z) -
1.0 / (double)(x + y + z);
} else
ans += 1.0 / (double)dis(i, j);
}
printf("%.10f\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
std::set<std::pair<int, int> > set;
int head[3010], nxt[6010], b[6010], k, n, u, v, fa[3010], cnt, rt;
bool vis[3010];
long double ans;
void push(int s, int t) {
nxt[++k] = head[s];
head[s] = k;
b[k] = t;
}
void getloop(int x, int f) {
if (vis[x]) {
u = x, v = f;
return;
}
vis[x] = 1;
fa[x] = f;
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f) getloop(b[i], x);
}
void dfs(int x, int f, int tot, int dis) {
vis[x] = 1;
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f && !vis[b[i]]) {
tot += set.count(std::make_pair(b[i], x)) ? 1 : 0;
++dis;
if (!tot)
ans += (long double)1 / (long double)dis;
else
ans += (long double)1 / (long double)dis +
(long double)1 / (long double)(dis - tot - tot + cnt) -
(long double)1 / (long double)(dis - tot + cnt - 1);
dfs(b[i], x, tot, dis);
--dis;
tot -= set.count(std::make_pair(b[i], x)) ? 1 : 0;
}
}
int main() {
scanf("%d", &n);
for (int i = 1, s, t; i <= n; i++) {
scanf("%d%d", &s, &t);
++s, ++t;
push(s, t);
push(t, s);
}
getloop(1, 0);
memset(vis, 0, sizeof vis);
int tem = u;
while (tem) {
vis[tem] = 1;
tem = fa[tem];
}
int last = 0;
tem = v;
while (tem) {
if (!last && vis[tem]) last = tem;
vis[tem] ^= 1;
tem = fa[tem];
}
vis[last] = 1;
set.insert(std::make_pair(u, v));
set.insert(std::make_pair(v, u));
while (u) {
if (vis[u] && vis[fa[u]])
set.insert(std::make_pair(u, fa[u])),
set.insert(std::make_pair(fa[u], u));
u = fa[u];
}
while (v) {
if (vis[v] && vis[fa[v]])
set.insert(std::make_pair(v, fa[v])),
set.insert(std::make_pair(fa[v], v));
v = fa[v];
}
for (int i = 1; i <= n; i++) cnt += vis[i];
for (int i = 1; i <= n; i++)
memset(vis, 0, sizeof vis), rt = i, dfs(i, 0, 0, 1);
printf("%.10Lf", ans + (long double)n);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
vector<int> g[N];
int n, cirLen, stk[N], top, vis[N], findCir, onCir[N];
double ans;
void dfs(int v, int p) {
stk[++top] = v;
vis[v] = 1;
for (int d : g[v])
if (d != p) {
if (!vis[d]) {
dfs(d, v);
if (findCir) return;
} else if (vis[d] == 1) {
int t;
do {
t = stk[top--];
onCir[t] = 1;
++cirLen;
;
} while (t != d);
findCir = 1;
return;
}
}
vis[v] = 2;
--top;
}
void getAns(double x, double y) {
;
if (y <= 1.0)
ans += 1.0 / x;
else {
double z = x - y + cirLen;
ans -= 1.0 / z;
ans += 1.0 / x;
ans += 1.0 / (x - y + cirLen - y + 2);
}
}
void count(int v, int x, int y) {
vis[v] = 1;
;
getAns(x, y);
for (int d : g[v])
if (!vis[d]) count(d, x + 1, y + onCir[d]);
}
int main(int argc, char *argv[]) {
scanf("%d", &n);
for (int i = 1; i <= (n); ++i) {
int u, v;
scanf("%d%d", &u, &v);
++u, ++v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= (n); ++i) {
memset(vis, 0, sizeof(vis));
count(i, 1, onCir[i]);
}
printf("%.10f\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void ckmax(T& a, T b) {
if (b > a) a = b;
}
template <typename T>
void ckmin(T& a, T b) {
if (b < a) a = b;
}
struct _in {
const _in operator,(int& a) const {
a = 0;
char k = getchar();
int f = 1;
for (; !isdigit(k); k = getchar())
if (k == '-') f = -1;
for (; isdigit(k); k = getchar()) a = a * 10 + k - '0';
a *= f;
return *this;
}
} in;
const int N = 3000 + 5;
int fr[N << 1], to[N << 1], h[N], tot;
void ade(int u, int v) {
tot++;
fr[tot] = h[u];
to[tot] = v;
h[u] = tot;
}
int n, stk[N], top, vis[N], dep[N], inc[N], C[N], Ctop;
;
void dfs1(int u, int f) {
stk[++top] = u, vis[u] = 1, dep[u] = dep[f] + 1;
for (int i = h[u]; i; i = fr[i])
if (to[i] != f) {
int v = to[i];
if (vis[to[i]]) {
if (dep[to[i]] > dep[u])
continue;
else
for (int j = (dep[to[i]]); j <= (dep[u]); ++j)
inc[stk[j]] = 1, C[++Ctop] = stk[j];
} else
dfs1(to[i], u);
}
top--;
}
double ans, tmp;
int rt;
void dfs2(int u, int f, int Y) {
vis[u] = 1;
if (Y <= 0 && dep[u] - 1)
ans += tmp = (1.00 / (dep[u]));
else if (dep[u] - 1)
ans += tmp =
(1.00 / (dep[u] - 1 + 1) + 1.00 / (dep[u] - 1 - Y + (Ctop - Y) + 1) -
1.00 / (dep[u] - 1 - Y + Ctop));
for (int i = h[u]; i; i = fr[i])
if (to[i] != f) {
if (vis[to[i]]) continue;
if (!inc[to[i]]) {
if (inc[u])
dfs2(to[i], u, Y);
else
dfs2(to[i], u, Y);
} else {
if (!inc[u])
dfs2(to[i], u, 0);
else
dfs2(to[i], u, Y + 1);
}
}
}
int main() {
in, n;
for (int i = (1); i <= (n); ++i) {
int x, y;
in, x, y;
++x, ++y;
ade(x, y), ade(y, x);
}
for (int i = (1); i <= (n); ++i) {
rt = i;
memset(vis, 0, sizeof vis);
dfs1(i, 0);
memset(vis, 0, sizeof vis);
dfs2(i, 0, inc[i] ? 0 : -1);
memset(dep, 0, sizeof dep);
Ctop = 0;
}
printf("%.10f\n", ans + n);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 3500;
int N;
struct Edge {
int y, nx;
} E[MX << 1];
int H[MX], ec;
void Add(int x, int y) { E[++ec].y = y, E[ec].nx = H[x], H[x] = ec; }
int B[MX], dfn[MX], low[MX], dc;
int Cr[MX], Ic[MX], cc, stk[MX], tp;
void Tarjan(int x, int f) {
B[x] = 1, dfn[x] = low[x] = ++dc, stk[++tp] = x;
for (int i = H[x]; i; i = E[i].nx) {
if (B[E[i].y] == 0)
Tarjan(E[i].y, x), low[x] = min(low[x], low[E[i].y]);
else if (E[i].y != f)
low[x] = min(low[x], dfn[E[i].y]);
}
if (dfn[x] == low[x]) {
if (stk[tp] != x) {
int z = 0;
while (z != x) z = stk[tp--], Cr[++cc] = z, Ic[z] = 1;
} else
tp--;
}
}
int C[MX], Ds[MX][MX];
void dfs1(int x, int f, int c) {
C[x] = c;
for (int i = H[x]; i; i = E[i].nx)
if (E[i].y != f && !Ic[E[i].y]) dfs1(E[i].y, x, c);
}
void dfs2(int x, int f, int rt, int d) {
Ds[rt][x] = d;
for (int i = H[x]; i; i = E[i].nx)
if (E[i].y != f && C[x] == C[E[i].y]) dfs2(E[i].y, x, rt, d + 1);
}
double Calc(int x, int y) {
if (C[x] == C[y]) return 1.0 / Ds[x][y];
int rx = Cr[C[x]], ry = Cr[C[y]];
int a = Ds[x][rx] + Ds[y][ry] + (C[x] - C[y] + cc) % cc - 1;
int b = Ds[x][rx] + Ds[y][ry] + (C[y] - C[x] + cc) % cc - 1;
int c = Ds[x][rx] + Ds[y][ry] + cc - 2;
return 1.0 / a + 1.0 / b - 1.0 / c;
}
int main() {
scanf("%d", &N);
for (int i = (1); i <= (N); ++i) {
int x, y;
scanf("%d%d", &x, &y), ++x, ++y;
Add(x, y), Add(y, x);
}
Tarjan(1, 0);
for (int i = (1); i <= (cc); ++i) dfs1(Cr[i], 0, i);
for (int i = (1); i <= (N); ++i) dfs2(i, 0, i, 1);
double ans = 0;
for (int i = (1); i <= (N); ++i)
for (int j = (1); j <= (N); ++j) ans += Calc(i, j);
printf("%.10f\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int head[5010];
int from[5010];
int to[100010];
int nex[100010];
int dep[5010];
int q[5010];
int cnt;
int vis[5010];
int bel[5010];
int num[100010];
double ans;
int tot;
int x, y, n, m;
int f[5010][17];
void add(int x, int y, int z) {
nex[++tot] = head[x];
head[x] = tot;
to[tot] = y;
num[tot] = z;
}
bool dfs(int x, int fa) {
vis[x] = 1;
for (int i = head[x]; i; i = nex[i]) {
if (num[i] != fa) {
if (vis[to[i]]) {
for (int j = x; j != to[i]; j = from[j]) {
q[++cnt] = j;
}
q[++cnt] = to[i];
return true;
} else {
from[to[i]] = x;
if (dfs(to[i], num[i])) {
return true;
}
}
}
}
return false;
}
void find(int x, int fa, int rt) {
bel[x] = rt;
dep[x] = dep[fa] + 1;
f[x][0] = fa;
for (int i = 1; i <= 15; i++) {
f[x][i] = f[f[x][i - 1]][i - 1];
}
for (int i = head[x]; i; i = nex[i]) {
if (to[i] != fa && !vis[to[i]]) {
find(to[i], x, rt);
}
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) {
swap(x, y);
}
int d = dep[x] - dep[y];
for (int i = 0; i <= 15; i++) {
if (d & (1 << i)) {
x = f[x][i];
}
}
if (x == y) {
return x;
}
for (int i = 15; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
}
}
return f[x][0];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++, y++;
add(x, y, i);
add(y, x, i);
}
dfs(1, 0);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= cnt; i++) {
vis[q[i]] = 1;
}
for (int i = 1; i <= cnt; i++) {
find(q[i], 0, i);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (bel[i] == bel[j]) {
ans += (double)1 / (dep[i] + dep[j] - 2 * dep[lca(i, j)] + 1);
} else {
int X = dep[i] + dep[j];
int Y = abs(bel[i] - bel[j]) - 1;
int Z = cnt - Y - 2;
ans +=
(double)1 / (X + Y) + (double)1 / (X + Z) - (double)1 / (X + Y + Z);
}
}
}
printf("%.7f", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int head[5009], tot, du[5009], n, cnt;
double ans;
int vis[5009];
inline int rd() {
int x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
struct edge {
int n, to;
} e[5009 << 1];
inline void add(int u, int v) {
e[++tot].n = head[u];
e[tot].to = v;
head[u] = tot;
}
inline void tpsort() {
for (int i = 1; i <= n; ++i)
if (du[i] == 1) q.push(i);
cnt = n;
while (!q.empty()) {
int u = q.front();
q.pop();
cnt--;
for (int i = head[u]; i; i = e[i].n) {
int v = e[i].to;
du[v]--;
if (du[v] == 1) q.push(v);
}
}
}
void dfs(int u, int h, int l) {
if (h <= 1)
ans += (double)1 / (double)l;
else
ans += (double)1 / (double)l + (double)1 / ((double)(cnt - h + 2) + l - h) -
(double)1 / ((double)cnt + l - h);
for (int i = head[u]; i; i = e[i].n)
if (vis[u] != vis[e[i].to]) {
int v = e[i].to;
;
vis[e[i].to] = vis[u];
dfs(v, h + (du[v] > 1), l + 1);
}
}
int main() {
n = rd();
int x, y;
for (int i = 1; i <= n; ++i) {
x = rd() + 1;
y = rd() + 1;
du[x]++;
du[y]++;
add(x, y);
add(y, x);
}
tpsort();
for (int i = 1; i <= n; ++i) {
vis[i] = i;
dfs(i, du[i] > 1, 1);
}
printf("%.12lf", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3333;
int n, m, a[N], b[N], c[N], d[N], f[N];
vector<int> v[N], h;
double ans, w[N];
int fnd(int x) {
if (f[x] == x) return x;
return f[x] = fnd(f[x]);
}
void dfs0(int u, int o) {
if (b[u]) return;
if (!b[o]) h.push_back(u);
b[u] = 1;
for (int i = v[u].size(); i--;) dfs0(v[u][i], o);
if (!b[o]) h.pop_back();
}
void dfs1(int u, int fa) {
if (b[u]) return;
b[u] = 1;
if (!c[u]) c[u] = c[fa];
for (int i = v[u].size(); i--;) dfs1(v[u][i], u);
}
void dfs2(int u, int fa) {
if (b[u]) return;
b[u] = 1;
d[u] = d[fa] + 1;
for (int i = v[u].size(); i--;) dfs2(v[u][i], u);
}
int main() {
int i, j, x, y, z;
scanf("%d", &n);
for (i = 1; i <= n; i = i + 1) f[i] = i, w[i] = (double)1.0 / (double)i;
for (i = 1; i <= n; i = i + 1) {
scanf("%d%d", &x, &y);
x++, y++;
if (fnd(x) != fnd(y))
v[x].push_back(y), v[y].push_back(x), f[fnd(x)] = fnd(y);
else
a[0] = x, a[1] = y;
}
memset(b, 0, sizeof(b));
dfs0(a[1], a[0]);
m = h.size();
for (i = 2; i <= m; i = i + 1) a[i] = h[i - 1];
for (i = 1; i <= m; i = i + 1) c[a[i]] = i;
memset(b, 0, sizeof(b));
dfs1(a[1], 0);
for (i = 1; i <= n; i = i + 1) {
memset(b, 0, sizeof(b));
dfs2(i, 0);
for (j = 1; j <= n; j = j + 1) {
if (c[i] == c[j] && i < j) ans += w[d[j]];
if (c[i] >= c[j]) continue;
x = d[j], z = x + c[i] - 1 + m - c[j], y = z - (c[j] - c[i] - 1);
ans += w[x] + w[y] - w[z];
}
}
ans += ans + n;
printf("%.9lf", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3000 + 10;
struct Graph {
int id, next;
} g[MAXN * 2];
int st[MAXN], dep[MAXN], fa[MAXN], bel[MAXN], n, lca[MAXN][MAXN], num[MAXN];
bool vis[MAXN];
vector<int> L;
void Add(int tot, int x, int y) {
g[tot].id = y, g[tot].next = st[x], st[x] = tot;
}
int find_loop(int x, int fa) {
vis[x] = true;
for (int i = st[x]; i != -1; i = g[i].next)
if (g[i].id != fa) {
if (vis[g[i].id]) {
L.push_back(x);
return dep[g[i].id];
}
dep[g[i].id] = dep[x] + 1;
int y = find_loop(g[i].id, x);
if (y == -1) continue;
if (dep[x] >= y) L.push_back(x);
return y;
}
return -1;
}
void DFS(int x, int fat) {
for (int i = st[x]; i != -1; i = g[i].next)
if (g[i].id != fat && num[g[i].id] == -1) {
dep[g[i].id] = dep[x] + 1, bel[g[i].id] = bel[x];
fa[g[i].id] = x;
DFS(g[i].id, x);
}
}
void init() {
scanf("%d", &n);
memset(st, -1, sizeof(st));
for (int i = 1; i <= n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
++x, ++y;
Add(i * 2, x, y), Add(i * 2 + 1, y, x);
}
find_loop(1, 0);
memset(num, -1, sizeof(num));
for (int i = 0; i < (int)L.size(); ++i) num[L[i]] = i;
for (int i = 0; i < (int)L.size(); ++i) {
dep[L[i]] = 1, bel[L[i]] = L[i];
DFS(L[i], 0);
}
}
int LCA(int x, int y) {
if (lca[x][y]) return lca[x][y];
if (x == y) return x;
if (dep[x] > dep[y]) return (lca[x][y] = LCA(fa[x], y));
return (lca[x][y] = LCA(x, fa[y]));
}
void solve() {
double CC = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (bel[i] == bel[j]) {
int x = LCA(i, j);
CC += 1.0 / (dep[i] + dep[j] - dep[x] * 2 + 1);
} else {
int x = dep[i] + dep[j],
y = (num[bel[i]] - num[bel[j]] + L.size()) % L.size() - 1,
z = (num[bel[j]] - num[bel[i]] + L.size()) % L.size() - 1;
CC += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
printf("%.10lf\n", CC);
}
int main() {
init();
solve();
fclose(stdin);
fclose(stdout);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
struct Vertex {
bool vis;
int head, top, dist;
Vertex() : vis(false), head(0), top(0), dist(0) {}
} vertex[3005];
struct Edge {
int to, next;
Edge(int __to = 0, int __next = 0) : to(__to), next(__next) {}
} edge[6005];
int n, ptr, dist[3005][3005];
std::vector<int> circle;
void addEdge(int u, int v) {
edge[++ptr] = Edge(v, vertex[u].head), vertex[u].head = ptr;
edge[++ptr] = Edge(u, vertex[v].head), vertex[v].head = ptr;
}
int findCircle(int p, int f) {
vertex[p].vis = true;
for (int i = vertex[p].head; i; i = edge[i].next) {
int x = edge[i].to, temp;
if (x == f) continue;
if (vertex[x].vis) {
vertex[x].top = x;
vertex[p].top = p;
circle.push_back(x);
circle.push_back(p);
return 1;
} else if (temp = findCircle(x, p)) {
if (temp == 1 && !vertex[p].top) {
vertex[p].top = p;
circle.push_back(p);
return 1;
} else {
return -1;
}
}
}
vertex[p].vis = false;
return 0;
}
void BFS(int s) {
for (int i = 1; i <= n; ++i) vertex[i].vis = false;
std::queue<int> q;
q.push(s), vertex[s].vis = true, dist[s][s] = 0;
while (!q.empty()) {
int p = q.front();
q.pop();
for (int i = vertex[p].head; i; i = edge[i].next) {
int x = edge[i].to;
if (vertex[x].vis) continue;
vertex[x].vis = true, q.push(x);
dist[s][x] = dist[s][p] + 1;
}
}
}
void findTop(int s) {
std::queue<int> q;
q.push(s), vertex[s].vis = true;
while (!q.empty()) {
int p = q.front();
q.pop();
for (int i = vertex[p].head; i; i = edge[i].next) {
int x = edge[i].to;
if (vertex[x].top) continue;
vertex[x].top = s, q.push(x);
}
}
}
int main() {
double ans = 0;
std::cin >> n;
for (int i = 1; i <= n; ++i) {
int u, v;
std::cin >> u >> v;
addEdge(u + 1, v + 1);
}
findCircle(1, 0);
for (int i = 1; i <= n; ++i) BFS(i);
for (auto x : circle) findTop(x);
for (int i = 1; i <= n; ++i) vertex[i].dist = dist[i][vertex[i].top];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
double temp = 0.0;
if (vertex[i].top == vertex[j].top) {
temp = 1.0 / (dist[i][j] + 1);
} else {
double x = vertex[i].dist + vertex[j].dist + 2,
y = dist[vertex[i].top][vertex[j].top] - 1,
z = circle.size() - y - 2;
temp = 1 / (x + y) + 1 / (x + z) - 1 / (x + y + z);
}
ans += temp;
}
std::cout << std::fixed << std::setprecision(9) << ans << std::endl;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
char ch;
x = 0;
bool fl = false;
while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
;
(fl == true) && (x = -x);
}
template <class T>
inline void output(T x) {
if (x / 10) output(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void ot(T x) {
if (x < 0) putchar('-'), x = -x;
output(x);
putchar(' ');
}
template <class T>
inline void prt(T a[], int st, int nd) {
for (register int i = st; i <= nd; ++i) ot(a[i]);
putchar('\n');
}
namespace Miracle {
const int N = 3003;
int n;
struct node {
int nxt, to;
} e[2 * N];
int hd[N], cnt;
void add(int x, int y) {
e[++cnt].nxt = hd[x];
e[cnt].to = y;
hd[x] = cnt;
}
int sta[N], top;
bool vis[N];
bool fl;
int on[N], mem[N], num;
void fin(int x, int fa) {
sta[++top] = x;
vis[x] = 1;
for (register int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fa) continue;
if (vis[y]) {
if (!fl) {
fl = true;
int z;
do {
z = sta[top--];
mem[++num] = z;
on[z] = num;
} while (z != y);
}
} else
fin(y, x);
}
if (sta[top] == x) sta[top--] = 0;
}
int be[N];
int dis[N];
void dfs(int x, int fa, int rt) {
be[x] = rt;
for (register int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fa) continue;
if (on[y]) continue;
dis[y] = dis[x] + 1;
dfs(y, x, rt);
}
}
double ans;
int rt;
void sol(int x, int d) {
vis[x] = 1;
if (x != rt) {
if (be[x] == be[rt]) {
ans += (double)1.0 / ((double)d);
} else {
int a = dis[rt] + dis[x], b = abs(on[be[x]] - on[be[rt]]) - 1,
c = num - 2 - b;
ans += (double)1.0 / ((double)a + b) + (double)1.0 / ((double)a + c) -
(double)1.0 / ((double)a + b + c);
}
}
for (register int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].to;
if (vis[y]) continue;
sol(y, d + 1);
}
}
int main() {
rd(n);
int x, y;
for (register int i = 1; i <= n; ++i) {
rd(x);
rd(y);
++x;
++y;
add(x, y);
add(y, x);
}
fin(1, 0);
for (register int i = 1; i <= num; ++i) {
dis[mem[i]] = 1;
dfs(mem[i], 0, mem[i]);
}
for (register int i = 1; i <= n; ++i) {
memset(vis, 0, sizeof vis);
rt = i;
sol(i, 1);
}
ans += n;
printf("%.10lf", ans);
return 0;
}
} // namespace Miracle
signed main() {
Miracle::main();
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
int tot = 1;
int fir[3010], nex[3010 << 1], got[3010 << 1];
inline void AddEdge(int x, int y) {
nex[++tot] = fir[x], fir[x] = tot, got[tot] = y;
}
int vis[3010], cir[3010], siz;
int ins[3010], stk[3010], top;
inline int find(int x, int fa) {
if (ins[x]) {
int v;
do {
vis[cir[++siz] = v = stk[top--]] = true;
} while (v != x);
return true;
}
ins[stk[++top] = x] = true;
for (int i = fir[x]; i; i = nex[i]) {
if (got[i] == fa) continue;
if (find(got[i], x)) return true;
}
ins[stk[top--]] = false;
return false;
}
int col[3010], par[3010][21], dep[3010];
inline int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20; i >= 0; i--)
if (dep[par[x][i]] >= dep[y]) x = par[x][i];
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (par[x][i] != par[y][i]) x = par[x][i], y = par[y][i];
return par[x][0];
}
inline void dfs(int x, int fa, int c) {
col[x] = c, par[x][0] = fa, dep[x] = dep[fa] + 1;
for (int i = 1; i <= 20; i++) par[x][i] = par[par[x][i - 1]][i - 1];
for (int i = fir[x]; i; i = nex[i])
if (got[i] != fa && !vis[got[i]]) dfs(got[i], x, c);
}
inline int dis(int x, int y) {
return dep[x] + dep[y] - 2 * dep[lca(x, y)] + 1;
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
int x = read() + 1, y = read() + 1;
AddEdge(x, y), AddEdge(y, x);
}
find(1, 0);
double ans = 0;
for (int i = 1; i <= siz; i++) dfs(cir[i], 0, i);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (col[i] == col[j])
ans += 1.0 / dis(i, j);
else {
int x = dep[i] + dep[j], y = abs(col[i] - col[j]) - 1, z = siz - y - 2;
ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
}
printf("%0.10lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int g() {
char ch;
bool f = 0;
while (!((ch = getchar() - 48) >= 0))
if (ch == -3) f = 1;
int v = ch;
while (((ch = getchar() - 48) >= 0)) v = v * 10 + ch;
return f ? -v : v;
}
const int Maxn = 3005;
vector<int> p[Maxn];
long double ans;
int n, R;
bool mark[Maxn], belong[Maxn];
int FC(int x, int fa) {
mark[x] = true;
for (int i = 0; i < p[x].size(); i++)
if (!mark[p[x][i]]) {
int te = FC(p[x][i], x);
if (te) {
if (te > 0) belong[x] = true, R++;
return te == x ? -1 : te;
}
} else if (p[x][i] != fa) {
belong[x] = true;
R = 1;
return p[x][i];
}
}
int pre, tot;
void dfs(int x) {
mark[x] = true;
pre += belong[x] == true;
tot++;
if (pre > 1) {
int C = tot + R - pre, B = pre - 2, A = R - pre;
ans += 1.0 / (C - B) + 1.0 / (C - A) - 1.0 / C;
} else
ans += 1.0 / tot;
for (int i = 0; i < p[x].size(); i++)
if (!mark[p[x][i]]) dfs(p[x][i]);
pre -= belong[x] == true;
tot--;
}
int x, y;
int main() {
n = g();
for (int i = 1; i <= n; i++) {
x = g() + 1;
y = g() + 1;
p[x].push_back(y);
p[y].push_back(x);
}
FC(1, 0);
for (int i = 1; i <= n; i++) memset(mark, 0, sizeof(mark)), dfs(i);
printf("%.9lf\n", (double)ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n, tot, fst[N], to[2 * N], nxt[2 * N], cir[N], pos[N], len, dep[N], fa[N],
subt[N], st[N], top, dis[N];
bool vis[N];
void addedge(int u, int v) {
nxt[++tot] = fst[u];
fst[u] = tot;
to[tot] = v;
nxt[++tot] = fst[v];
fst[v] = tot;
to[tot] = u;
}
void fnd(int u) {
if (len) return;
vis[u] = true;
for (int i = fst[u]; i && !len; i = nxt[i])
if (to[i] != fa[u]) {
if (vis[to[i]]) {
for (int j = u; j != to[i]; j = fa[j]) cir[++len] = j, pos[j] = len;
cir[++len] = to[i], pos[to[i]] = len;
return;
}
fa[to[i]] = u;
fnd(to[i]);
}
}
void dfs(int u) {
st[++top] = u;
for (int i = fst[u]; i; i = nxt[i])
if (to[i] != fa[u] && !pos[to[i]]) {
fa[to[i]] = u;
dep[to[i]] = dep[u] + 1;
subt[to[i]] = subt[u];
dfs(to[i]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i <= n; i++) {
scanf("%d%d", &u, &v);
addedge(u + 1, v + 1);
}
fnd(1);
double ans = 0;
for (int i = 1; i <= len; i++) {
fa[cir[i]] = dep[cir[i]] = 0;
subt[cir[i]] = i;
top = 0;
dfs(cir[i]);
for (int j = 1; j <= top; j++) {
for (int k = 1; k <= top; k++) vis[st[k]] = false;
static int q[N];
int h = 0, t = 0;
q[t++] = st[j];
dis[q[0]] = 1;
vis[q[0]] = true;
while (h < t) {
int u = q[h++];
ans += 1.0 / dis[u];
for (int k = fst[u]; k; k = nxt[k])
if (!vis[to[k]] && (to[k] == cir[i] || !pos[to[k]])) {
q[t++] = to[k];
vis[to[k]] = true;
dis[to[k]] = dis[u] + 1;
}
}
}
}
for (int u = 1; u <= n; u++)
for (int v = 1; v <= n; v++)
if (subt[u] != subt[v]) {
int A = dep[u] + dep[v] + abs(subt[u] - subt[v]) + 1,
B = dep[u] + dep[v] + len - abs(subt[u] - subt[v]) + 1,
C = dep[u] + dep[v] + len;
ans += 1.0 / A + 1.0 / B - 1.0 / C;
}
printf("%.10f\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n;
double ans;
double inv[N];
struct Edge {
int ce;
int hd[N], nxt[N * 2], v[N * 2];
void ade(int x, int y) {
ce++;
nxt[ce] = hd[x];
v[ce] = y;
hd[x] = ce;
}
};
Edge T;
int lenc, tp;
int fa[N], dep[N], cir[N], lc[N], rc[N];
void dfsc(int u) {
for (int i = T.hd[u]; i; i = T.nxt[i]) {
int v = T.v[i];
if (v == fa[u]) continue;
if (dep[v]) {
if (dep[v] > dep[u]) continue;
lenc = 1;
tp = v;
lc[u] = 0;
rc[u] = dep[u] - dep[v] - 1;
cir[u] = 1;
for (int t = u; t != v; t = fa[t]) {
lenc++;
lc[fa[t]] = lc[t] + 1;
rc[fa[t]] = rc[t] - 1;
cir[fa[t]] = 1;
}
cir[tp] = 0;
} else {
fa[v] = u;
dep[v] = dep[u] + 1;
dfsc(v);
}
}
}
void dfsa(int u, int lstc) {
if (!lstc)
ans += inv[dep[u]];
else {
int len1, len2, len3;
if (!cir[u])
len1 = dep[u] - dep[lstc] + 1 + lc[lstc] + dep[tp],
len2 = len1 - lc[lstc] + rc[lstc],
len3 = dep[u] - dep[lstc] + lenc + dep[tp] - 1;
else
len1 = 1 + lc[u] + dep[tp], len2 = 1 + rc[u] + dep[tp],
len3 = lenc + dep[tp] - 1;
ans += inv[len1] + inv[len2] - inv[len3];
}
if (cir[u]) lstc = u;
for (int i = T.hd[u]; i; i = T.nxt[i]) {
int v = T.v[i];
if (v == fa[u] || fa[v] != u) continue;
dfsa(v, lstc);
}
}
void calc(int u) {
dep[u] = 1;
dfsc(u);
dfsa(u, 0);
lenc = tp = 0;
memset(fa, 0, sizeof(dep));
memset(dep, 0, sizeof(dep));
memset(cir, 0, sizeof(cir));
}
int main() {
int x, y;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &x, &y), x++, y++, T.ade(x, y), T.ade(y, x);
for (int i = 1; i <= n; i++) inv[i] = 1.0 / i;
for (int i = 1; i <= n; i++) calc(i);
printf("%.12lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> it;
int n, f[3010], x, y, fa[3010], dep[3010], tot, L[3010], t, tmp[3010],
num[3010], belong[3010];
vector<int> E[3010];
int dis[3010][3010];
bool vis[3010];
queue<int> h;
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;
}
int find(int x) { return (f[x] == x) ? x : f[x] = find(f[x]); }
void Union(int x, int y) { f[find(y)] = find(x); }
void dfs(int u) {
vis[u] = 1;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (!vis[v]) dep[v] = dep[u] + 1, fa[v] = u, dfs(v);
}
}
void Dfs(int u, int st) {
vis[u] = 1;
belong[u] = st;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (!vis[v]) Dfs(v, st);
}
}
void bfs(int st) {
memset(vis, 0, sizeof(vis));
vis[st] = 1;
dis[st][st] = 0;
h.push(st);
while (h.size()) {
int u = h.front();
h.pop();
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (!vis[v]) {
vis[v] = 1;
dis[st][v] = dis[st][u] + 1;
h.push(v);
}
}
}
}
double Get(int x, int y) {
if (x == y) return 1;
if (belong[x] == belong[y]) return (double)1 / (dis[x][y] + 1);
double X = dis[x][belong[x]] + dis[y][belong[y]];
double Y = (num[belong[x]] - num[belong[y]] + tot) % tot + 1;
double Z = (num[belong[y]] - num[belong[x]] + tot) % tot + 1;
return ((Z - 2) / (X + Y) + (Y - 2) / (X + Z) + 1) / (X + Y + Z - 2);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++) {
read(x);
read(y);
x++;
y++;
if (find(x) != find(y)) {
Union(x, y);
E[x].push_back(y), E[y].push_back(x);
} else
it = make_pair(x, y);
}
dfs(1);
x = it.first, y = it.second;
if (dep[x] < dep[y]) swap(x, y);
for (; dep[x] != dep[y]; x = fa[x]) L[++tot] = x;
for (; x != y; x = fa[x], y = fa[y]) L[++tot] = x, tmp[++t] = y;
L[++tot] = x;
for (int i = t; i; i--) L[++tot] = tmp[i];
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= tot; i++) num[L[i]] = i, vis[L[i]] = 1;
for (int i = 1; i <= tot; i++) Dfs(L[i], L[i]);
for (int i = 1; i <= n; i++) bfs(i);
double ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) ans += Get(i, j);
printf("%.9lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-10;
inline int read() {
static char ch;
bool sgn = false;
while (ch = getchar(), ch < '0' || ch > '9')
if (ch == '-') sgn = true;
int res = ch - 48;
while (ch = getchar(), ch >= '0' && ch <= '9') res = res * 10 + ch - 48;
return sgn ? -res : res;
}
const int N = 3e3 + 5;
double p[N][N], ans;
int dis[N][N][2], f[N], father[N], dep[N], a[N], b[N], now;
vector<int> E[N];
bool incircle[N], bo[N], passcircle[N][N];
void dfs(int x, int f, int d) {
for (int i = E[x].size() - 1; i >= 0; i--) {
int u = E[x][i];
if (u == f || u == now) continue;
if (dis[now][u][0] == 0) {
dis[now][u][0] = d + 1;
dfs(u, x, d + 1);
} else {
if (d + 1 < dis[now][u][0]) {
dis[now][u][1] = dis[now][u][0];
dis[now][u][0] = d + 1;
dfs(u, x, d + 1);
} else {
if (dis[now][u][1] == 0) {
dis[now][u][1] = d + 1;
dfs(u, x, d + 1);
} else {
if (dis[now][u][1] > d + 1) {
dis[now][u][1] = d + 1;
dfs(u, x, d + 1);
}
}
}
}
}
}
void Dfs(int x, int f) {
dep[x] = dep[f] + 1;
father[x] = f;
for (int i = E[x].size() - 1; i >= 0; i--) {
int u = E[x][i];
if (u == f) continue;
Dfs(u, x);
}
}
void DFS(int x, int f, int cir) {
bo[x] = 1;
passcircle[now][x] = (cir >= 2 ? 1 : 0);
for (int i = E[x].size() - 1; i >= 0; i--) {
int u = E[x][i];
if (u == f || bo[u]) continue;
DFS(u, x, cir + incircle[u]);
}
}
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
int n = read(), x, y;
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++) {
a[i] = read(), b[i] = read();
a[i]++;
b[i]++;
int fa = find(a[i]), fb = find(b[i]);
if (fa != fb) {
E[a[i]].push_back(b[i]);
E[b[i]].push_back(a[i]);
f[fa] = fb;
} else {
x = a[i];
y = b[i];
}
}
Dfs(1, 0);
E[x].push_back(y);
E[y].push_back(x);
incircle[x] = incircle[y] = 1;
while (dep[x] > dep[y]) {
x = father[x];
incircle[x] = 1;
}
swap(x, y);
while (dep[x] > dep[y]) {
x = father[x];
incircle[x] = 1;
}
while (x != y) {
x = father[x];
incircle[x] = 1;
y = father[y];
incircle[y] = 1;
}
for (now = 1; now <= n; now++) dfs(now, 0, 1);
for (now = 1; now <= n; now++) {
for (int i = 1; i <= n; i++) bo[i] = 0;
DFS(now, 0, incircle[now]);
}
int num = 0;
for (int i = 1; i <= n; i++) num += incircle[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) {
ans += 1;
continue;
}
if (passcircle[i][j]) {
ans += 1.0 / dis[i][j][0] + 1.0 / dis[i][j][1] -
1.0 / ((dis[i][j][0] + dis[i][j][1] - num - 2) / 2 + num);
} else {
ans += 1.0 / dis[i][j][0];
}
}
}
printf("%.10f", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, next;
} e[6005];
int n, m, head[3005], d[3005], d2[3005], num, c;
bool ok[3005];
queue<int> q;
double ans;
inline void insert(int u, int v) {
e[++num].to = v;
e[num].next = head[u];
head[u] = num;
e[++num].to = u;
e[num].next = head[v];
head[v] = num;
}
inline void dfs(int now) {
ok[now] = true;
for (int i = head[now]; i; i = e[i].next)
if (!ok[e[i].to]) {
d2[e[i].to] = d2[now] + 1;
if (d[e[i].to] == 0) {
d[e[i].to] = d[now] + 1;
ans += 1.0 / d[e[i].to];
} else {
ans +=
1.0 / d2[e[i].to] - 1.0 / ((d[e[i].to] + d2[e[i].to] + c) / 2 - 1);
}
dfs(e[i].to);
}
ok[now] = false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int u, v;
scanf("%d%d", &u, &v);
u++;
v++;
d[u]++;
d[v]++;
insert(u, v);
}
c = n;
for (int i = 1; i <= n; i++)
if (d[i] == 1) {
q.push(i);
c--;
}
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = head[now]; i; i = e[i].next) {
d[e[i].to]--;
if (d[e[i].to] == 1) {
q.push(e[i].to);
c--;
}
}
}
for (int i = 1; i <= n; i++) {
memset(d, 0, sizeof(d));
memset(d2, 0, sizeof(d2));
d[i] = d2[i] = 1;
dfs(i);
}
ans += n;
printf("%.6lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int n, stk[N], top, num[N], cyc[N], idx;
bool vis[N], instk[N], fl;
vector<int> v[N];
void dfs(int pos, int fa) {
stk[++top] = pos;
instk[pos] = 1;
for (auto &i : v[pos]) {
if (i == fa) continue;
if (!instk[i]) return dfs(i, pos);
if (fl) continue;
fl = 1;
while (1) {
int cur = stk[top--];
cyc[++idx] = cur;
num[cur] = idx;
if (cur == i) break;
}
}
--top;
instk[pos] = 0;
}
int rt[N], dep[N];
void dfs(int pos, int fa, int root) {
rt[pos] = root;
dep[pos] = dep[fa] + 1;
for (auto &i : v[pos])
if (i != fa && !num[i]) dfs(i, pos, root);
}
int root;
double ans;
void solve(int pos, int d) {
vis[pos] = 1;
if (rt[pos] == rt[root])
ans += 1.0 / d;
else {
int x = dep[root] + dep[pos], y = abs(num[rt[pos]] - num[rt[root]]) - 1,
z = idx - 2 - y;
ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
for (auto &i : v[pos])
if (!vis[i]) solve(i, d + 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int t1, t2;
for (int i = 1; i <= n; i++)
cin >> t1 >> t2, ++t1, ++t2, v[t1].push_back(t2), v[t2].push_back(t1);
dfs(1, 0);
for (int i = 1; i <= idx; i++) dfs(cyc[i], 0, cyc[i]);
cout << endl;
for (int i = 1; i <= n; i++)
memset(vis, 0, sizeof(vis)), root = i, solve(i, 1);
printf("%.8lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 5;
template <typename T>
T _abs(T a) {
return (a < 0) ? (-a) : (a);
}
int n, m;
vector<int> cir;
vector<int> G[N];
stack<int> S;
bool vis[N], onc[N];
void dfs(int p, int fa) {
if (vis[p]) {
int cur;
do {
cur = S.top();
S.pop();
onc[cur] = true;
cir.push_back(cur);
} while (cur != p);
throw 1;
}
vis[p] = true;
S.push(p);
for (auto& e : G[p]) {
if (e ^ fa) {
dfs(e, p);
}
}
}
int dep[N], id[N];
vector<int> T[N];
void dfs(int p, int fa, int d, int _id) {
dep[p] = d, id[p] = _id;
T[_id].push_back(p);
for (auto& e : G[p]) {
if ((e ^ fa) && !onc[e]) {
dfs(e, p, d + 1, _id);
}
}
}
double ans = 0;
void dfs(int p, int fa, int dis) {
ans += 1.0 / dis;
for (auto& e : G[p]) {
if (id[e] == id[p] && e != fa) {
dfs(e, p, dis + 1);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i <= n; i++) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
try {
dfs(0, -1);
} catch (int) {
m = cir.size();
}
for (int i = 0; i < m; i++) {
dfs(cir[i], -1, 0, i);
}
for (int i = 0; i < n; i++) {
dfs(i, -1, 1);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
if (i == j) continue;
int d1 = _abs(i - j), d2 = m - d1;
for (auto& p : T[i]) {
for (auto& q : T[j]) {
ans += 1.0 / (dep[p] + dep[q] + d1 + 1);
ans += 1.0 / (dep[p] + dep[q] + d2 + 1);
ans -= 1.0 / (dep[p] + dep[q] + m);
}
}
}
}
printf("%.9lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int N, lk[6005], nx[6005], head[3005], s[3005], d[3005], dfn[3005], tot, L,
p[3005], q[3005], fa[3005], f[3005][3005];
bool b[3005];
void init() {
scanf("%d", &N);
auto add = [&](int u, int v, int t) {
lk[t] = v, nx[t] = head[u], head[u] = t;
};
for (int i = 1, u, v; i <= N; i++)
scanf("%d%d", &u, &v), add(++u, ++v, i), add(v, u, i + N);
}
void loop(int u) {
dfn[u] = ++tot;
for (int i = head[u], v; v = lk[i], i; i = nx[i])
if (fa[u] != v && !dfn[v]) fa[v] = u, loop(v);
for (int i = head[u], v; v = lk[i], i; i = nx[i])
if (dfn[v] > dfn[u] && fa[v] != u) {
for (int x = v; x != u; x = fa[x]) q[++L] = x, b[x] = 1;
q[++L] = u, b[u] = 1;
}
}
void dfs(int u) {
for (int i = head[u], v; v = lk[i], i; i = nx[i])
if (!b[v] && !d[v]) d[v] = d[u] + 1, p[v] = p[u], dfs(v);
}
void dfs(int u, int s) {
for (int i = head[u], v; v = lk[i], i; i = nx[i])
if (!f[s][v]) f[s][v] = f[s][u] + 1, dfs(v, s);
}
void doit() {
loop(1);
for (int i = 1; i <= L; i++)
s[q[i]] = s[q[i - 1]] + 1, p[q[i]] = q[i], d[q[i]] = 1, dfs(q[i]);
for (int i = 1; i <= N; i++) f[i][i] = 1, dfs(i, i);
double ans = 0;
for (int i = 1; i <= N; i++)
for (int j = i + 1; j <= N; j++)
if (p[i] == p[j])
ans += 1.0 / f[i][j];
else {
int x = d[i] + d[j], y = s[p[i]] - s[p[j]] - 1, z = L - y - 2;
if (y < 0) y += L, z -= L;
ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
printf("%.9lf\n", ans * 2 + N);
}
int main() {
init();
doit();
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
const double inf = 1e121;
const double eps = 1e-10;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long randint(long long l, long long r) {
long long out = rng() % (r - l + 1) + l;
return out >= l ? out : out + r - l + 1;
}
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (long long i = 0; i < static_cast<long long>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
template <typename A, typename B, typename C, typename D, typename E>
string to_string(tuple<A, B, C, D, E> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + "," +
to_string(get<4>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <typename T>
struct is_pair {
static const bool value = false;
};
template <typename T, typename U>
struct is_pair<std::pair<T, U>> {
static const bool value = true;
};
const long long INF = 0x3f3f3f3f3f3f3f3fll;
template <typename T>
typename enable_if<!is_integral<T>::value && !is_pair<T>::value, void>::type
read(T& x) {
cin >> x;
}
long long read() {
char c;
long long out = 0, f = 1;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar()) {
}
if (c == '-') {
f = -1;
c = getchar();
}
for (; isdigit(c); c = getchar()) out = (out << 3) + (out << 1) + c - '0';
return out * f;
}
template <typename T>
typename enable_if<is_integral<T>::value, T>::type read(T& x) {
char c;
T f = 1;
x = 0;
for (c = getchar(); !isdigit(c) && c != '-'; c = getchar()) {
}
if (c == '-') {
f = -1;
c = getchar();
}
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
return x *= f;
}
char read(char& x) {
for (x = getchar(); isspace(x); x = getchar()) {
}
return x;
}
double read(double& x) {
scanf("%lf", &x);
return x;
}
template <typename T>
typename enable_if<!is_integral<T>::value && !is_pair<T>::value, void>::type
write(const T& x) {
cout << x;
}
template <typename T>
typename enable_if<is_integral<T>::value, void>::type write(const T& x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void write(const char& x) { putchar(x); }
void write(const double& x) { printf("%.12lf", x); }
template <typename T>
typename enable_if<is_pair<T>::value, void>::type read(T& x) {
read(x.first);
read(x.second);
}
template <typename T>
typename enable_if<is_pair<T>::value, void>::type write(const T& x) {
write(x.first);
putchar(' ');
write(x.second);
}
template <typename T, typename... Args>
void read(T& x, Args&... args) {
read(x);
read(args...);
}
template <
typename OutputIt,
typename = typename enable_if<
is_same<output_iterator_tag,
typename iterator_traits<OutputIt>::iterator_category>::value ||
(is_base_of<forward_iterator_tag, typename iterator_traits<OutputIt>::
iterator_category>::value &&
!is_const<OutputIt>::value)>::type>
void read(OutputIt __first, OutputIt __last) {
for (; __first != __last; ++__first) read(*__first);
}
template <
typename InputIt,
typename = typename enable_if<is_base_of<
input_iterator_tag,
typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wts(InputIt __first, InputIt __last) {
bool isFirst = true;
for (; __first != __last; ++__first) {
if (isFirst)
isFirst = false;
else
putchar(' ');
write(*__first);
}
putchar('\n');
}
template <
typename InputIt,
typename = typename enable_if<is_base_of<
input_iterator_tag,
typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wtb(InputIt __first, InputIt __last) {
for (; __first != __last; ++__first) {
write(*__first);
putchar('\n');
}
}
template <typename T>
void wts(const T& x) {
write(x);
putchar(' ');
}
template <typename T>
void wtb(const T& x) {
write(x);
putchar('\n');
}
template <typename T>
void wte(const T& x) {
write(x);
exit(0);
}
template <typename T, typename... Args>
void wts(const T& x, Args... args) {
wts(x);
wts(args...);
}
template <typename T, typename... Args>
void wtb(const T& x, Args... args) {
wts(x);
wtb(args...);
}
template <typename T, typename... Args>
void wte(const T& x, Args... args) {
wts(x);
wte(args...);
}
template <typename T1, typename T2>
inline bool up(T1& x, const T2& y) {
return x < y ? x = y, 1 : 0;
}
template <typename T1, typename T2>
inline bool dn(T1& x, const T2& y) {
return y < x ? x = y, 1 : 0;
}
template <typename T1, typename T2, typename T3>
inline bool inRange(const T1& x, const T2& l, const T3& r) {
return !(x < l) && !(r < x);
}
template <typename T1, typename T2>
inline auto minOfDifferentTypes(const T1& x, const T2& y)
-> decltype(x < y ? x : y) {
return x < y ? x : y;
}
template <typename T1, typename T2>
inline auto maxOfDifferentTypes(const T1& x, const T2& y)
-> decltype(x < y ? y : x) {
return x < y ? y : x;
}
template <typename T1, typename T2, typename T3>
inline T1& madd(T1& x, const T2& y, const T3& modulo) {
return x = (long long)(x + y + modulo) % modulo;
}
template <typename T1, typename T2, typename T3>
inline T1& mmul(T1& x, const T2& y, const T3& modulo) {
return x = (long long)x * y % modulo;
}
inline long long modadd(long long x, long long y, long long modulo) {
return (x + y) >= modulo ? x + y - modulo : x + y;
}
inline long long isinf(long long x) { return x < INF ? x : -1; }
inline void yesno(bool x) { wtb(x ? "Yes" : "No"); }
signed main() {
long long n = read();
vector<vector<pair<long long, long long>>> g(n + 1);
for (long long i = (1), iend = (n); i <= iend; ++i) {
long long u = read() + 1;
long long v = read() + 1;
g[u].emplace_back(v, i);
g[v].emplace_back(u, i);
}
long long dfntot = 0;
vector<long long> dfn(n + 1);
stack<long long> stk;
vector<bool> oncycle(n + 1);
vector<long long> cycle;
function<void(long long, long long)> findCycle = [&](long long u,
long long pa) {
dfn[u] = ++dfntot;
stk.push(u);
for (auto x : g[u]) {
long long v = x.first;
long long id = x.second;
if (id == pa) continue;
if (!dfn[v])
findCycle(v, id);
else if (dfn[v] < dfn[u]) {
while (1) {
long long t = stk.top();
stk.pop();
cycle.push_back(t);
oncycle[t] = true;
if (t == v) break;
}
}
}
if (cycle.empty()) stk.pop();
};
findCycle(1, 0);
vector<long long> dep(n + 1), treeId(n + 1);
vector<vector<long long>> dis(n + 1, vector<long long>(n + 1)),
tree(cycle.size());
function<void(long long, long long, long long)> getTree =
[&](long long u, long long pa, long long id) {
tree[id].push_back(u);
treeId[u] = id;
for (auto x : g[u]) {
long long v = x.first;
if (oncycle[v] || v == pa) continue;
dep[v] = dep[u] + 1;
getTree(v, u, id);
}
};
for (long long i = (0), iend = (cycle.size() - 1); i <= iend; ++i)
getTree(cycle[i], 0, i);
double ans = 0;
function<void(long long, long long, long long)> calcTree =
[&](long long u, long long pa, long long d) {
ans += 1.0 / d;
for (auto x : g[u]) {
long long v = x.first;
if (v == pa || treeId[v] != treeId[u]) continue;
calcTree(v, u, d + 1);
}
};
for (long long i = (0), iend = (cycle.size() - 1); i <= iend; ++i) {
for (auto u : tree[i]) calcTree(u, 0, 1);
for (long long j = (i + 1), jend = (cycle.size() - 1); j <= jend; ++j) {
for (auto u : tree[i]) {
for (auto v : tree[j]) {
long long x = dep[u] + dep[v];
long long y = j - i;
long long z = cycle.size() - y;
ans += 2.0 / (x + y + 1) + 2.0 / (x + z + 1) - 2.0 / (x + y + z);
}
}
}
}
wtb(ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
long long x = 1, s = 0;
while (c < '0' || c > '9') {
if (c == '-') x = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
s = s * 10 + c - '0';
c = getchar();
}
return s * x;
}
const int N = 4000;
int n, x, y, top, flag, deep[N], pd[N], st[N], vis[N], f[N][13], bh[N], cnt,
cd[N], head;
vector<int> v[N];
double ans = 0;
void dfs(int u, int fa) {
f[u][0] = fa;
deep[u] = deep[fa] + 1;
for (int i = 1; i <= 12; i++) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = 0; i < v[u].size(); i++) {
if (v[u][i] == fa || vis[v[u][i]]) continue;
dfs(v[u][i], u);
}
}
void find(int u, int fa) {
if (pd[u]) {
vis[u] = 1;
while (st[top] != u) {
vis[st[top]] = 1;
bh[st[top]] = ++cnt;
cd[++head] = st[top];
top--;
}
flag = 1;
cd[++head] = u;
bh[u] = ++cnt;
return;
}
pd[u] = 1;
st[++top] = u;
for (int i = 0; i < v[u].size(); i++) {
if (v[u][i] == fa) continue;
find(v[u][i], u);
if (flag) return;
}
}
int tiao(int x) {
for (int i = 12; i >= 0; i--) {
if (f[x][i]) x = f[x][i];
}
return x;
}
int lca(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 12; i >= 0; i--) {
if (deep[x] - (1 << i) >= deep[y]) x = f[x][i];
}
if (x == y) return x;
for (int i = 12; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
}
}
return f[x][0];
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
x = read() + 1;
y = read() + 1;
v[x].push_back(y);
v[y].push_back(x);
}
find(1, 0);
for (int i = 1; i <= head; i++) dfs(cd[i], cd[i]);
for (int i = 1; i <= n; i++) {
for (int k = 1; k <= n; k++) {
int u = tiao(i);
int v = tiao(k);
if (u == v) {
int g = lca(i, k);
int D = deep[i] + deep[k] - 2 * deep[g] + 1;
ans += 1.0 / D;
} else {
int l1 = abs(bh[u] - bh[v]) + 1;
int l2 = cnt - l1 + 2;
int L = deep[i] - deep[v] + deep[k] - deep[u];
if (L + l1) ans += 1.0 / (L + l1);
if (L + l2) ans += 1.0 / (L + l2);
ans -= 1.0 / (L + cnt);
}
}
}
printf("%.8lf", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v[3030];
void init() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int ai, bi;
scanf("%d%d", &ai, &bi);
v[ai].push_back(bi);
v[bi].push_back(ai);
}
}
bool oncyc[3030], instk[3030];
int vst[3030], p[3030][14], dep[3030], stk[3030];
int cycsz;
void go(int now, int prt, int tdep) {
p[now][0] = prt;
dep[now] = tdep;
stk[tdep] = now;
vst[now] = 1;
instk[now] = true;
for (int son : v[now]) {
if (son == prt) continue;
if (vst[son]) {
if (!instk[son]) continue;
cycsz = tdep - dep[son] + 1;
for (int i = dep[son]; i <= tdep; i++) oncyc[stk[i]] = true;
} else
go(son, now, tdep + 1);
}
instk[now] = false;
}
int cyc[3030];
void go2(int now, int prt, int sum) {
if (oncyc[now]) sum++;
cyc[now] = sum;
vst[now] = 2;
for (int son : v[now]) {
if (son == prt || vst[son] == 2) continue;
go2(son, now, sum);
}
}
void build_pp() {
for (int i = 1; i < 14; i++)
for (int j = 0; j < n; j++) p[j][i] = p[p[j][i - 1]][i - 1];
}
inline int lca(int ui, int vi) {
if (dep[ui] > dep[vi]) swap(ui, vi);
int dlt = dep[vi] - dep[ui];
for (int i = 0; i < 14; i++)
if ((dlt >> i) & 1) vi = p[vi][i];
if (ui == vi) return ui;
for (int i = 14 - 1; i >= 0; i--)
if (p[ui][i] != p[vi][i]) {
ui = p[ui][i];
vi = p[vi][i];
}
return p[ui][0];
}
inline double cal(int a, int b) {
if (a == b) return 1.0;
int tlca = lca(a, b);
int bet = dep[b] + dep[a] - 2 * dep[tlca] + 1;
int cnt = cyc[b] + cyc[a] - 2 * cyc[tlca] + oncyc[tlca];
if (cnt <= 1) return 1.0 / (double)bet;
bet -= cnt;
int p1 = cnt, p2 = cycsz - cnt + 2;
return 1.0 / (double)(bet + p1) + 1.0 / (double)(bet + p2) -
1.0 / (double)(bet + cycsz);
}
void solve() {
go(0, 0, 0);
go2(0, 0, 0);
build_pp();
double ans = 0.0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ans += cal(i, j);
printf("%.9f\n", ans);
}
int main() {
init();
solve();
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int a = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
a = a * 10 + c - 48;
c = getchar();
}
return a;
}
const int _ = 3001;
struct Edge {
int end, upEd;
} Ed[_ << 1];
int head[_], cntEd, N;
void addEd(int a, int b) {
Ed[++cntEd] = (Edge){b, head[a]};
head[a] = cntEd;
}
vector<int> cir;
int dep[_], bel[_], len[_];
int getcir(int x, int p) {
dep[x] = dep[p] + 1;
int cur = 0;
for (int i = head[x]; i; i = Ed[i].upEd)
if (Ed[i].end != p)
if (dep[Ed[i].end] && dep[Ed[i].end] < dep[x]) {
cir.push_back(x);
return Ed[i].end;
} else if (!dep[Ed[i].end]) {
int t = getcir(Ed[i].end, x);
if (t) cur = t;
}
if (cur)
cir.push_back(x);
else
dep[x] = 0;
return cur == x ? 0 : cur;
}
long double ans;
list<int> dfs(int x, int p, int t) {
list<int> child;
bel[x] = t;
dep[x] = dep[p] + 1;
child.push_back(dep[x]);
++ans;
for (int i = head[x]; i; i = Ed[i].upEd)
if (!dep[Ed[i].end]) {
list<int> tp = dfs(Ed[i].end, x, t);
for (auto p : tp)
for (auto q : child) ans += 2.0 / (p + q - 2 * dep[x] + 1);
child.insert(child.end(), tp.begin(), tp.end());
}
return child;
}
int main() {
N = read();
for (int i = 1; i <= N; ++i) {
int a = read() + 1, b = read() + 1;
addEd(a, b);
addEd(b, a);
}
getcir(1, 0);
for (auto t : cir) dfs(t, 0, t);
for (int i = 0; i < cir.size(); ++i) len[cir[i]] = i + 1;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) {
int p = bel[i], q = bel[j];
if (p != q) {
int a = dep[i] + dep[j];
if (len[p] > len[q]) swap(p, q);
int b = len[q] - len[p] - 1, c = cir.size() - 2 - b;
ans += 1.0 / (a + b + c) + b * 1.0 / (a + b + c) / (a + c) +
c * 1.0 / (a + b + c) / (a + b);
}
}
cout << fixed << setprecision(8) << ans;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 5;
int read() {
int x = 0, f = 1;
char ch;
while (!isdigit(ch = getchar())) (ch == '-') && (f = -f);
for (x = ch ^ 48; isdigit(ch = getchar());
x = (x << 3) + (x << 1) + (ch ^ 48))
;
return x * f;
}
template <class T>
T Abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
T Max(T a, T b) {
return a > b ? a : b;
}
template <class T>
T Min(T a, T b) {
return a < b ? a : b;
}
struct Edge {
int to;
Edge *nxt;
Edge(int to, Edge *nxt) : to(to), nxt(nxt) {}
} * head[N];
void add(int x, int y) { head[x] = new Edge(y, head[x]); }
double ans;
int n, m, top, tot, is[N], cir[N], sta[N], dep[N], vis[N], bel[N], fa[N][15];
void dfs(int x, int f) {
dep[x] = dep[f] + 1;
for (Edge *i = head[x]; i; i = i->nxt) {
if (i->to == f) continue;
dfs(i->to, x);
}
}
void solve1() {
for (int i = 1; i <= n; ++i) {
dfs(i, 0);
for (int j = 1; j <= n; ++j) ans += 1.0 / dep[j];
}
printf("%.7f\n", ans);
}
bool findcir(int x, int f) {
if (vis[x]) {
int y;
do {
y = sta[top--];
is[y] = 1;
cir[++tot] = y;
} while (y != x);
return 1;
}
sta[++top] = x;
vis[x] = 1;
for (Edge *i = head[x]; i; i = i->nxt) {
if (i->to != f && findcir(i->to, x)) return 1;
}
vis[x] = 0;
top--;
return 0;
}
void dfs(int x, int f, int c) {
bel[x] = c;
fa[x][0] = f;
dep[x] = dep[f] + 1;
for (int i = 1; i <= 14; ++i) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (Edge *i = head[x]; i; i = i->nxt) {
if (i->to != f && !is[i->to]) dfs(i->to, x, c);
}
}
int Lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 14; ~i; --i)
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 14; ~i; --i)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int Dis(int x, int y) { return dep[x] + dep[y] - dep[Lca(x, y)] * 2 + 1; }
void solve2() {
findcir(1, 0);
for (int i = 1; i <= tot; ++i) dfs(cir[i], 0, i);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (bel[i] == bel[j])
ans += 1.0 / Dis(i, j);
else {
int x = dep[i] + dep[j], y = Abs(bel[i] - bel[j]) - 1, z = tot - 2 - y;
ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
}
}
printf("%.7f\n", ans);
}
int main() {
n = read();
m = n;
for (int i = 1, x, y; i <= n; ++i)
x = read() + 1, y = read() + 1, add(x, y), add(y, x);
if (m == n - 1)
return solve1(), 0;
else
return solve2(), 0;
fclose(stdin);
fclose(stdout);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> edge[3100];
int cir[3100], vi[3100], cirlen;
int _lca[3100][3100], fa[3100], dep[3100];
void dfs2(int x) {
dep[x] = dep[fa[x]] + 1;
vi[x] = 1;
for (typeof((edge[x]).begin()) y = (edge[x]).begin(); y != (edge[x]).end();
y++)
if (*y != fa[x]) {
if (vi[*y]) {
if (dep[*y] < dep[x]) {
for (int p = x; p != fa[*y]; p = fa[p]) cir[p] = ++cirlen;
}
} else
fa[*y] = x, dfs2(*y);
}
}
int lca(int x, int y) {
if (_lca[x][y]) return _lca[x][y];
if (x == y) return _lca[x][y] = x;
if (dep[x] < dep[y]) swap(x, y);
return _lca[x][y] = lca(fa[x], y);
}
void dfs(int x, int f) {
if (vi[x]) return;
vi[x] = 1;
fa[x] = f;
dep[x] = dep[f] + 1;
for (typeof((edge[x]).begin()) y = (edge[x]).begin(); y != (edge[x]).end();
y++)
if (!cir[*y]) cir[*y] = cir[x], dfs(*y, x);
}
int main() {
cin >> n;
for (int _ = (1); _ <= (n); _++) {
int x, y;
scanf("%d%d", &x, &y);
x++, y++;
edge[x].push_back(y);
edge[y].push_back(x);
}
dfs2(1);
memset(vi, 0, sizeof vi);
for (int x = (1); x <= (n); x++)
if (cir[x]) dfs(x, 0);
double ans = 0;
for (int x = (1); x <= (n); x++)
for (int y = (1); y <= (n); y++)
if (cir[x] != cir[y]) {
int X = dep[x] + dep[y], mn = min(cir[x], cir[y]),
mx = max(cir[x], cir[y]), Y = mx - mn - 1, Z = cirlen - mx + mn - 1;
ans += 1.0 / (X + Y) + 1.0 / (X + Z) - 1.0 / (X + Y + Z);
} else {
int f = lca(x, y);
ans += 1.0 / (dep[x] + dep[y] - dep[f] * 2 + 1);
}
printf("%.7lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int res = 0, q = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') q = -1, ch = getchar();
while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();
return res * q;
}
const double eps = 1e-12, pi = M_PI;
const int oo = (int)2e9, mod = (int)1e9 + 7;
const long long INF = (long long)1e17;
const int N = (int)3e3;
typedef int arr[N + 10];
typedef int arre[2 * N + 10];
int n, m, tot = 1, j, k, sc;
arr g, ft;
arre pt, nt, e;
bool v[N + 10], ic[N + 10];
double ans;
void Link(int x, int y) {
pt[++tot] = y, nt[tot] = g[x], g[x] = tot;
pt[++tot] = x, nt[tot] = g[y], g[y] = tot;
}
void Find(int x, int fa) {
v[x] = 1;
for (int i = g[x]; i; i = nt[i])
if (pt[i] != fa) {
if (v[pt[i]])
j = x, k = pt[i], e[i] = e[i ^ 1] = 1;
else
Find(pt[i], x);
}
}
void Dfs(int x, int fa) {
ft[x] = fa;
for (int i = g[x]; i; i = nt[i])
if (pt[i] != fa && !e[i]) Dfs(pt[i], x);
}
void Dp(int x, int fa, int dp, int ds) {
if (ds <= 1)
ans += 1. / dp;
else
ans += 1. / dp + 1. / (dp - ds + sc - ds + 2) - 1. / (dp - ds + sc);
for (int i = g[x]; i; i = nt[i])
if (pt[i] != fa && !e[i]) Dp(pt[i], x, dp + 1, ds + ic[pt[i]]);
}
int main() {
scanf(
"%d"
"\n",
&n);
for (int i = (1), end = (n); i <= end; ++i)
scanf(
"%d"
"%d"
"\n",
&j, &k),
++j, ++k, Link(j, k);
Find(1, 0);
Dfs(j, 0);
for (int now = k; now != j; now = ft[now]) ++sc, ic[now] = 1;
++sc, ic[j] = 1;
for (int i = (1), end = (n); i <= end; ++i) Dp(i, 0, 1, ic[i]);
printf(
"%.10lf"
"\n",
ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
int n, dep[maxn], point[maxn << 1], nextp[maxn << 1], head[maxn], cir[maxn],
len, ecnt;
void ins(int u, int v) {
point[++ecnt] = v;
nextp[ecnt] = head[u];
head[u] = ecnt;
}
int dfs(int x, int f) {
dep[x] = dep[f] + 1;
int i, to, tmp, res = 0;
for (i = head[x]; i; i = nextp[i]) {
to = point[i];
if (to == f) continue;
if (dep[to]) {
if (dep[to] < dep[x])
len = res = dep[x] - dep[to] + 1;
else
continue;
} else if (tmp = dfs(to, x))
res = tmp;
}
if (res) cir[x] = 1, res--;
return res;
}
int a[maxn], b[maxn];
void dfs2(int x) {
int i, to;
for (i = head[x]; i; i = nextp[i]) {
to = point[i];
if (a[to] == -1) {
a[to] = a[x] + 1 - cir[to];
b[to] = b[x] + cir[to];
dfs2(to);
}
}
}
double ans;
int main() {
int i, j, u, v;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &u, &v);
++u;
++v;
ins(u, v);
ins(v, u);
}
dfs(1, 0);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) a[j] = b[j] = -1;
b[i] = cir[i];
a[i] = 1 - cir[i];
dfs2(i);
for (j = 1; j <= n; j++) {
ans += 1. / (a[j] + b[j]);
if (b[j] > 2) {
ans += 1. / (a[j] + len - b[j] + 2);
ans -= 1. / (a[j] + len);
}
}
}
printf("%.10f\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, next;
} e[6005];
int etot = 0;
int g[3005];
void ae(int u, int v) {
e[etot].v = v;
e[etot].next = g[u];
g[u] = etot++;
}
int n;
double ans = 0.0;
int pre[3005], vis[3005];
int cyc[3005], len = 0;
int oncy[3005] = {0};
int dfs(int u) {
vis[u] = 1;
for (int i = g[u]; ~i; i = e[i].next)
if (e[i].v != pre[u]) {
if (!vis[e[i].v]) {
pre[e[i].v] = u;
if (dfs(e[i].v)) return 1;
} else {
int p = u;
while (1) {
cyc[++len] = u;
oncy[u] = len;
if (u == e[i].v) break;
u = pre[u];
}
return 1;
}
}
return 0;
}
int dis[3005];
int belong[3005], tot = 0;
void dfs1(int u, int pre = -1) {
belong[u] = tot;
for (int i = g[u]; ~i; i = e[i].next)
if (e[i].v != pre && !oncy[e[i].v]) {
dis[e[i].v] = dis[u] + 1;
dfs1(e[i].v, u);
}
}
int cur;
void dfs2(int u, int pre, int d) {
ans += 1.0 / d;
for (int i = g[u]; ~i; i = e[i].next)
if (e[i].v != pre && belong[e[i].v] == cur) {
dfs2(e[i].v, u, d + 1);
}
}
int main() {
memset(g, -1, sizeof(g));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
x++, y++;
ae(x, y);
ae(y, x);
}
dfs(1);
for (int i = 1; i <= len; i++) tot++, dfs1(cyc[i]);
for (int i = 1; i <= n; i++) {
cur = belong[i];
dfs2(i, -1, 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (belong[i] != belong[j]) {
int tot = dis[i] + dis[j] + len, a = abs(belong[i] - belong[j]) - 1,
b = len - 2 - a;
ans += 1.0 / tot * (1 + a * 1.0 / (tot - a) + b * 1.0 / (tot - b));
}
printf("%.10lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int head[5010];
int from[5010];
int to[100010];
int nex[100010];
int dep[5010];
int q[5010];
int cnt;
int vis[5010];
int bel[5010];
int num[100010];
double ans;
int tot;
int x, y, n, m;
int f[5010][17];
void add(int x, int y, int z) {
nex[++tot] = head[x];
head[x] = tot;
to[tot] = y;
num[tot] = z;
}
bool dfs(int x, int fa) {
vis[x] = 1;
for (int i = head[x]; i; i = nex[i]) {
if (num[i] != fa) {
if (vis[to[i]]) {
for (int j = x; j != to[i]; j = from[j]) {
q[++cnt] = j;
}
q[++cnt] = to[i];
return true;
} else {
from[to[i]] = x;
if (dfs(to[i], num[i])) {
return true;
}
}
}
}
return false;
}
void find(int x, int fa, int rt) {
bel[x] = rt;
dep[x] = dep[fa] + 1;
f[x][0] = fa;
for (int i = 1; i <= 15; i++) {
f[x][i] = f[f[x][i - 1]][i - 1];
}
for (int i = head[x]; i; i = nex[i]) {
if (to[i] != fa && !vis[to[i]]) {
find(to[i], x, rt);
}
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) {
swap(x, y);
}
int d = dep[x] - dep[y];
for (int i = 0; i <= 15; i++) {
if (d & (1 << i)) {
x = f[x][i];
}
}
if (x == y) {
return x;
}
for (int i = 15; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
}
}
return f[x][0];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++, y++;
add(x, y, i);
add(y, x, i);
}
dfs(1, 0);
memset(vis, 0, sizeof(vis));
if (!cnt) {
q[++cnt] = 1;
}
for (int i = 1; i <= cnt; i++) {
vis[q[i]] = 1;
}
for (int i = 1; i <= cnt; i++) {
find(q[i], 0, i);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (bel[i] == bel[j]) {
ans += (double)1 / (dep[i] + dep[j] - 2 * dep[lca(i, j)] + 1);
} else {
int X = dep[i] + dep[j];
int Y = abs(bel[i] - bel[j]) - 1;
int Z = cnt - Y - 2;
ans +=
(double)1 / (X + Y) + (double)1 / (X + Z) - (double)1 / (X + Y + Z);
}
}
}
printf("%.7f", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, mark[((int)3030)], pos[((int)3030)], dp[((int)12)][((int)3030)],
dis[((int)3030)];
long double ans;
vector<int> e[((int)3030)], now, cycle;
bool dead[((int)3030)];
void dfs_cycle(int x, int par = 0) {
mark[x] = 1;
now.push_back(x);
for (auto u : e[x]) {
if (u == par || mark[u] == 2) continue;
if (mark[u]) {
for (int i = (int)now.size() - 1; i >= 0; i--) {
dead[now[i]] = 1;
pos[now[i]] = cycle.size();
cycle.push_back(now[i]);
if (now[i] == u) break;
}
continue;
}
dfs_cycle(u, x);
}
mark[x] = 2;
}
void pre_dfs(int x, int id) {
pos[x] = id;
for (int i = 1; i < ((int)12); i++) dp[i][x] = dp[i - 1][dp[i - 1][x]];
for (auto u : e[x])
if (!dead[u] && u != dp[0][x])
dis[u] = dis[x] + 1, dp[0][u] = x, pre_dfs(u, id);
}
int iPar(int x, int num) {
for (int i = 0; i < ((int)12); i++)
if ((num & (1 << i))) x = dp[i][x];
return x;
}
int lca(int x, int y) {
if (dis[x] < dis[y]) swap(x, y);
x = iPar(x, dis[x] - dis[y]);
if (x == y) return x;
for (int i = ((int)12) - 1; i >= 0; i--)
if (dp[i][x] != dp[i][y]) x = dp[i][x], y = dp[i][y];
return dp[0][x];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int v, u;
cin >> v >> u;
v++;
u++;
e[v].push_back(u);
e[u].push_back(v);
}
dfs_cycle(1);
for (auto u : cycle) pre_dfs(u, pos[u]);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
if (pos[i] == pos[j]) {
ans += (long double)1 / (dis[i] + dis[j] - 2 * dis[lca(i, j)] + 1);
continue;
}
int p = abs(pos[i] - pos[j]), q = (int)cycle.size() - p;
ans += (long double)1 / (dis[i] + dis[j] + p + 1) +
(long double)1 / (dis[i] + dis[j] + q + 1) -
(long double)1 / (dis[i] + dis[j] + p + q);
}
ans *= 2;
ans += n;
cout << fixed << setprecision(15) << ans << "\n";
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
vector<int> adj[3030];
int vst[3030], fa[3030];
int flag[3030];
int id[3030];
int dfs(int u) {
vst[u] = 1;
for (int v : adj[u]) {
if (v == fa[u]) continue;
if (vst[v]) {
int len = 0;
while (u != v) {
flag[u] = ++len;
id[len] = u;
u = fa[u];
}
flag[u] = ++len;
id[len] = u;
return len;
}
fa[v] = u;
int res = dfs(v);
if (res) return res;
}
return 0;
}
int top[3030], dep[3030];
void dfs(int u, int root, int f = -1) {
top[u] = root;
for (int v : adj[u]) {
if (v == f || flag[v]) continue;
dep[v] = dep[u] + 1;
dfs(v, root, u);
}
}
int dp[3030];
void dfs1(int u, int f = -1) {
for (int v : adj[u]) {
if (v == f || flag[v]) continue;
dp[v] = dp[u] + 1;
dfs1(v, u);
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int u, v;
gn(u, v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int len = dfs(0);
for (int i = 1; i <= len; i++) dfs(id[i], id[i]);
double ans = 0;
for (int i = 0; i < n; i++) {
int tmp = flag[top[i]];
flag[top[i]] = 0;
dp[i] = 0;
dfs1(i);
flag[top[i]] = tmp;
for (int j = 0; j < n; j++) {
if (top[i] == top[j]) {
ans += 1.0 / (dp[j] + 1);
continue;
}
int a = dep[i] + dep[j] + 2;
int b = abs(flag[top[i]] - flag[top[j]]) - 1;
int c = len - b - 2;
ans += 1.0 / (a + b) + 1.0 / (a + c) - 1.0 / (a + b + c);
}
}
printf("%.15lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3000 + 5;
int n;
int hd[N], to[N * 2], nxt[N * 2];
inline void add_se(int idx, int a, int b) {
nxt[idx] = hd[a];
hd[a] = idx;
to[idx] = b;
}
int sz_circ, circ[N], at_circ[N], stk[N], stkfr[N], b_stk;
;
bool vis[N], incirc[N], e_incirc[N];
bool dfs_circ(int u, int f) {
stk[++b_stk] = u;
vis[u] = true;
for (int e = hd[u]; e; e = nxt[e]) {
int v = to[e];
if (v == f) continue;
if (vis[v]) {
int vat = b_stk;
while (stk[vat] != v) --vat;
for (int i = vat; i <= b_stk; ++i) {
circ[++sz_circ] = stk[i];
incirc[stk[i]] = true;
at_circ[stk[i]] = sz_circ;
}
e_incirc[e >> 1] = true;
return true;
}
if (dfs_circ(v, u)) {
if (incirc[u]) e_incirc[e >> 1] = true;
return true;
}
}
--b_stk;
return false;
}
int inpart[N];
void dfs_part(int u, int f, int p) {
inpart[u] = p;
for (int e = hd[u]; e; e = nxt[e])
if (!e_incirc[e >> 1]) {
int v = to[e];
if (v == f) continue;
dfs_part(v, u, p);
}
}
int cnt[N];
void dfs_cnt(int u, int f) {
cnt[u] = cnt[f] + 1;
for (int e = hd[u]; e; e = nxt[e])
if (!e_incirc[e >> 1]) {
int v = to[e];
if (v == f) continue;
dfs_cnt(v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
++a, ++b;
add_se(i << 1, a, b), add_se(i << 1 | 1, b, a);
}
dfs_circ(1, 0);
for (int i = 1; i <= sz_circ; ++i) dfs_part(circ[i], 0, i);
double ans = 0.;
for (int i = 1; i <= n; ++i) {
dfs_cnt(i, 0);
for (int j = 1; j <= sz_circ; ++j)
if (j != inpart[i]) {
dfs_cnt(circ[j], 0);
}
for (int j = 1; j <= n; ++j) {
if (inpart[j] == inpart[i])
ans += 1. / cnt[j];
else {
int onepart = abs(inpart[i] - inpart[j]), cnt1 = cnt[j],
cnt2 = cnt[circ[inpart[i]]];
ans += 1. / (cnt1 + cnt2 + onepart - 1);
ans += 1. / (cnt1 + cnt2 + sz_circ - onepart - 1);
ans -= 1. / (cnt1 + cnt2 + sz_circ - 2);
}
}
}
printf("%.10f\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
namespace ringo {
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f ^= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (f) x = -x;
}
template <class T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar('0' + x % 10);
}
template <class T>
inline void print(T x, char c) {
print(x), putchar(c);
}
template <class T>
inline void print(T a, int l, int r, std::string s = "") {
if (s != "") std::cout << s << ": ";
for (int i = l; i <= r; i++) print(a[i], " \n"[i == r]);
}
const int N = 3010;
double ans;
bool vis[N], tag[N];
std::pair<int, int> R;
std::vector<int> C, S[N], G[N];
int n, m, dep[N], fa[N], d[N][N];
inline int dis(int u, int v) { return d[u][v]; }
inline int dis2(int u, int v) {
return std::min(d[u][R.first] + d[R.second][v] + 1,
d[u][R.second] + d[R.first][v] + 1);
}
std::vector<int> dfs(int u) {
vis[u] = 1;
std::vector<int> U(1, u);
for (auto v : G[u])
if (v != fa[u]) {
if (vis[v]) {
R = std::make_pair(u, v);
} else {
fa[v] = u, dep[v] = dep[u] + 1;
auto V = dfs(v);
for (auto i : U)
for (auto j : V) d[i][j] = d[j][i] = dep[i] + dep[j] - (dep[u] << 1);
for (auto v : V) U.push_back(v);
}
}
return U;
}
void addNodes(int u, int fa, std::vector<int> &S) {
S.push_back(u);
for (auto v : G[u])
if (v != fa) {
addNodes(v, u, S);
}
}
void main() {
read(n);
for (int u, v, i = 1; i <= n; i++) {
read(u), read(v), ++u, ++v;
G[u].push_back(v), G[v].push_back(u);
}
dfs(1);
int u = R.first, v = R.second;
if (dep[u] > dep[v]) std::swap(u, v);
while (dep[v] > dep[u]) tag[v] = 1, v = fa[v];
while (u != v) tag[u] = tag[v] = 1, u = fa[u], v = fa[v];
tag[u] = 1;
for (int i = 1; i <= n; i++)
if (tag[i]) C.push_back(i);
for (auto u : C) {
S[u].push_back(u);
for (auto v : G[u])
if (!tag[v]) {
addNodes(v, u, S[u]);
}
}
for (auto ru : C)
for (auto rv : C)
if (ru != rv) {
int y = dis(ru, rv) - 1, z = dis2(ru, rv) - 1;
for (auto u : S[ru])
for (auto v : S[rv]) {
int x = dis(u, ru) + dis(v, rv) + 2;
double w = (1 / (double)(x + y + z)) *
(1 + y / (double)(x + z) + z / (double)(x + y));
ans += w;
}
}
for (auto r : C)
for (auto u : S[r])
for (auto v : S[r])
if (u != v) {
double w = 1 / ((double)dis(u, v) + 1);
ans += w;
}
printf("%.15lf\n", ans + n);
}
} // namespace ringo
signed main() { return ringo::main(), 0; }
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[3000];
bool visited[3000];
bool incycle[3000];
int find_cycle(int u, int p) {
if (visited[u]) return u;
visited[u] = true;
for (int c : adj[u])
if (c != p) {
int x = find_cycle(c, u);
if (x != -1) {
incycle[u] = true;
return x == u ? -1 : x;
}
}
return -1;
}
double compute(int a, int b, int nc) {
if (b == 0) return 1.0 / (a + 1);
int c = nc - b;
return 1.0 / (a + b + c) + (double)(b - 1) / ((a + b + c) * (a + c + 1)) +
(double)(c - 1) / ((a + b + c) * (a + b + 1));
}
double dfs(int x, int a, int b, int nc) {
visited[x] = true;
double ans = compute(a, b, nc);
for (int c : adj[x])
if (!visited[c]) {
int aa = a, bb = b;
(incycle[x] && incycle[c] ? bb : aa)++;
ans += dfs(c, aa, bb, nc);
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
find_cycle(0, -1);
int nc = count(incycle, incycle + n, true);
double ans = 0;
for (int i = 0; i < n; i++) {
fill_n(visited, n, false);
ans += dfs(i, 0, 0, nc);
}
printf("%.15f\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& num) {
num = 0;
bool f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
num = num * 10 + ch - '0';
ch = getchar();
}
num = f ? num : -num;
}
template <class T>
inline void write(T x, char ch) {
int s[100];
if (x == 0) {
putchar('0');
putchar(ch);
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int num = 0;
while (x) {
s[num++] = (x % 10);
x = x / 10;
}
for (int i = (num - 1); i >= (0); i--) putchar(s[i] + '0');
putchar(ch);
}
int n, tot, siz;
int d[3005], d2[3005], last[3005];
double ans;
bool v[3005];
struct hh {
int next, to;
} e[7005];
queue<int> q;
void add(int a, int b) {
e[++tot].to = b;
e[tot].next = last[a];
last[a] = tot;
}
void insert(int a, int b) {
add(a, b);
add(b, a);
}
void dfs(int now) {
int i, j;
v[now] = true;
for (i = last[now]; i; i = e[i].next)
if (!v[e[i].to]) {
d2[e[i].to] = d2[now] + 1;
if (!d[e[i].to])
d[e[i].to] = d[now] + 1, ans += 1.0 / d[e[i].to];
else
ans += 1.0 / d2[e[i].to] - 2.0 / (d[e[i].to] + d2[e[i].to] + siz - 2);
dfs(e[i].to);
}
v[now] = false;
}
int main() {
int i, j, u, v, now;
read(n);
siz = n;
for (i = 1; i <= n; i++) {
read(u);
read(v);
u++;
v++;
d[u]++;
d[v]++;
insert(u, v);
}
for (i = 1; i <= n; i++)
if (d[i] == 1) q.push(i);
while (!q.empty()) {
now = q.front();
q.pop();
siz--;
for (i = last[now]; i; i = e[i].next)
if (--d[e[i].to] == 1) q.push(e[i].to);
}
for (i = 1; i <= n; i++) {
memset(d, 0, sizeof(d));
memset(d2, 0, sizeof(d2));
d[i] = d2[i] = 1;
dfs(i);
}
printf("%lf", ans + (double)n);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct graph {
int nxt, to;
} e[3005 << 1];
int g[3005], t[3005], d1[3005], d2[3005], n, cnt;
bool ins[3005];
double ans;
queue<int> q;
inline int read() {
int ret = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
ret = (ret << 1) + (ret << 3) + c - '0';
c = getchar();
}
return ret;
}
inline void addedge(int x, int y) {
e[++cnt].nxt = g[x];
g[x] = cnt;
e[cnt].to = y;
}
inline void toposort() {
int u;
for (int i = 1; i <= n; ++i)
if (t[i] == 1) q.push(i);
while (!q.empty()) {
u = q.front();
q.pop();
++cnt;
for (int i = g[u]; i; i = e[i].nxt)
if ((--t[e[i].to] == 1)) q.push(e[i].to);
}
}
inline void dfs(int u) {
ins[u] = true;
for (int i = g[u]; i; i = e[i].nxt)
if (!ins[e[i].to]) {
d2[e[i].to] = d2[u] + 1;
if (!d1[e[i].to]) {
d1[e[i].to] = d1[u] + 1;
ans += 1.0 / (double)(d1[e[i].to]);
} else {
ans += 1.0 / (double)(d2[e[i].to]) -
2.0 / (double)(d1[e[i].to] + d2[e[i].to] + cnt - 2);
}
dfs(e[i].to);
}
ins[u] = false;
}
inline void Aireen() {
n = read();
for (int i = 1, j, k; i <= n; ++i) {
j = read() + 1;
k = read() + 1;
addedge(j, k);
addedge(k, j);
++t[j];
++t[k];
}
cnt = 0;
toposort();
cnt = n - cnt;
for (int i = 1; i <= n; ++i) {
memset(d1, 0, sizeof(d1));
memset(d2, 0, sizeof(d2));
d1[i] = d2[i] = 1;
dfs(i);
}
printf("%.8lf\n", ans + n);
}
int main() {
Aireen();
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
int n;
int deg[MAXN];
vector<int> edges[MAXN];
double ans = 0;
int vis[MAXN];
int dist[MAXN], dist2[MAXN];
int cirsiz = 0;
void dfs(int x) {
vis[x] = 1;
for (auto nex : edges[x])
if (!vis[nex]) {
dist2[nex] = dist2[x] + 1;
if (!dist[nex]) {
dist[nex] = dist[x] + 1;
ans += 1. / dist[nex];
} else {
ans += 1. / dist2[nex] - 2. / (dist[nex] + dist2[nex] + cirsiz - 2);
}
dfs(nex);
}
vis[x] = 0;
}
int main() {
cin >> n;
for (int i = 1, a, b; i <= n; i++) {
cin >> a >> b;
edges[++a].push_back(++b);
edges[b].push_back(a);
deg[a]++;
deg[b]++;
}
queue<int> q;
for (int i = 1; i <= n; ++i)
if (deg[i] == 1) q.push(i), ++cirsiz;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (auto nex : edges[cur])
if (--deg[nex] == 1) {
q.push(nex);
++cirsiz;
}
}
cirsiz = n - cirsiz;
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
memset(dist, 0, sizeof(dist));
memset(dist2, 0, sizeof(dist2));
dist[i] = dist2[i] = 1;
dfs(i);
}
printf("%.10lf\n", ans + n);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
std::mt19937 rnd(time(NULL));
template <class T>
void cxk(T& a, T b) {
a = a > b ? a : b;
}
template <class T>
void cnk(T& a, T b) {
a = a < b ? a : b;
}
int fir[3010], dis[6010], nxt[6010], id;
void link(int a, int b) { nxt[++id] = fir[a], fir[a] = id, dis[id] = b; }
int cir[3010], stk[3010], tp, ins[3010], vis[3010], m, pos[3010], dep[3010];
void getcycle(int x, int fa = -1) {
vis[x] = 1;
stk[++tp] = x;
ins[x] = tp;
for (int i = fir[x]; i; i = nxt[i]) {
if (dis[i] == fa) continue;
if (!vis[dis[i]])
getcycle(dis[i], x);
else if (ins[dis[i]] && !m)
for (int j = ins[dis[i]]; j <= tp; ++j) cir[++m] = stk[j];
}
ins[x] = 0;
--tp;
}
int dist[3010][3010];
void DFS(int x) {
for (int i = fir[x]; i; i = nxt[i]) {
if (pos[dis[i]]) continue;
dep[dis[i]] = dep[x] + 1;
pos[dis[i]] = pos[x];
DFS(dis[i]);
}
}
void getdist(int x, int* di, int fa = -1) {
for (int i = fir[x]; i; i = nxt[i])
if (!di[dis[i]]) {
di[dis[i]] = di[x] + 1;
getdist(dis[i], di, x);
}
}
int main() {
int n = gi(), a, b;
for (int i = 1; i <= n; ++i)
a = gi() + 1, b = gi() + 1, link(a, b), link(b, a);
getcycle(1);
for (int i = 1; i <= m; ++i) pos[cir[i]] = i;
for (int i = 1; i <= m; ++i) DFS(cir[i]);
double ans = 0;
for (int i = 1; i <= n; ++i) dist[i][i] = 1, getdist(i, dist[i]);
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if (pos[i] == pos[j])
ans += 1. / dist[i][j];
else {
int a = abs(pos[i] - pos[j]), b = m - a;
ans += 1. / (dep[i] + dep[j] + a + 1);
ans += 1. / (dep[i] + dep[j] + b + 1);
ans -= 1. / (dep[i] + dep[j] + m);
}
printf("%.10lf\n", 2 * ans + n);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
const int maxn = 3010;
const int maxm = 6010;
using namespace std;
int ter[maxm], nxt[maxm], lnk[maxn], d[maxn];
int n, m, e, tot, opt[maxn], pos[maxn], dis[maxn], bel[maxn], fa[maxn][20];
bool cir[maxn], vis[maxn];
void add(int x, int y) {
ter[++e] = y, nxt[e] = lnk[x], lnk[x] = e;
ter[++e] = x, nxt[e] = lnk[y], lnk[y] = e;
++d[x], ++d[y];
}
void dfs(int p) {
cir[p] = false;
for (int i = lnk[p]; i; i = nxt[i])
if (cir[ter[i]]) pos[ter[i]] = pos[p] + 1, dfs(ter[i]);
}
void _dfs(int p, int fat) {
bel[p] = fat;
for (int i = lnk[p]; i; i = nxt[i])
if (vis[ter[i]]) {
vis[ter[i]] = false;
dis[ter[i]] = dis[p] + 1;
fa[ter[i]][0] = p;
_dfs(ter[i], fat);
}
}
void pre() {
memset(cir, true, sizeof(cir));
int he = 0, ta = 0;
for (int i = 1; i <= n; ++i)
if (d[i] == 1) opt[++ta] = i;
while (he != ta) {
++he;
int u = opt[he];
cir[u] = false;
for (int i = lnk[u]; i; i = nxt[i]) {
--d[ter[i]];
if (d[ter[i]] == 1) opt[++ta] = ter[i];
}
}
tot = 0;
for (int i = 1; i <= n; ++i) tot += cir[i];
for (int i = 1; i <= n; ++i)
if (cir[i]) {
pos[i] = 1;
dfs(i);
break;
}
memset(vis, true, sizeof(vis));
for (int i = 1; i <= n; ++i)
if (pos[i]) dis[i] = 0, vis[i] = false;
for (int i = 1; i <= n; ++i)
if (pos[i]) _dfs(i, i);
}
int lca(int x, int y) {
if (dis[x] < dis[y]) swap(x, y);
int tmp = dis[x] - dis[y];
for (int i = 15; i >= 0; --i)
if ((tmp >> i) & 1) x = fa[x][i];
if (x == y) return x;
for (int i = 15; i >= 0; --i)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 1; i <= n; ++i) scanf("%d%d", &x, &y), ++x, ++y, add(x, y);
pre();
for (int j = 1; (1 << j) <= n; ++j)
for (int i = 1; i <= n; ++i) fa[i][j] = fa[fa[i][j - 1]][j - 1];
double ans = n;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) {
if (bel[i] == bel[j])
ans += 1.0 / (dis[i] + dis[j] - 2.0 * dis[lca(i, j)] + 1);
else {
double A = dis[i] + dis[j] + 2,
B = abs(pos[bel[i]] - pos[bel[j]]) - 1,
C = tot - abs(pos[bel[i]] - pos[bel[j]]) - 1;
ans += 1.0 / (A + B) + 1.0 / (A + C) - 1.0 / (A + B + C);
}
}
printf("%.10lf", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29, N = 5e5 + 50, M = 1e6 + 5;
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void judge() {
freopen("data.in", "r", stdin);
freopen("data.out", "w", stdout);
}
int n, head[N], nxt[N], toit[N], s[N], top, cycle, cnt, bel[N], dis[N];
bool vis[N], flag, incir[N];
void adde(int a, int b) { toit[++cnt] = b, nxt[cnt] = head[a], head[a] = cnt; }
void getcir(int v, int fa) {
s[++top] = v;
vis[v] = 1;
for (int(k) = head[v]; k; k = nxt[k])
if (toit[k] != fa) {
if (flag) return;
if (vis[toit[k]]) {
while (s[top] != toit[k]) incir[s[top--]] = 1, cycle++;
cycle++;
incir[s[top]] = 1;
flag = 1;
return;
}
getcir(toit[k], v);
}
top--;
}
void dfs1(int v, int fa, int rt, int d) {
bel[v] = rt;
dis[v] = d;
for (int(k) = head[v]; k; k = nxt[k])
if (toit[k] != fa && !incir[toit[k]]) dfs1(toit[k], v, rt, d + 1);
}
int now, first;
double ans;
void dfs2(int v, int fa, int d) {
if (v == bel[now]) {
if (first) return;
first++;
}
ans += 1. / (d + 1);
for (int(k) = head[v]; k; k = nxt[k])
if (toit[k] != fa) dfs2(toit[k], v, d + 1);
}
int main() {
n = read();
for (int(i) = (1); (i) <= (n); (i)++) {
int a = read(), b = read();
a++;
b++;
adde(a, b);
adde(b, a);
}
getcir(1, 0);
for (int(i) = (1); (i) <= (n); (i)++)
if (incir[i]) dfs1(i, 0, i, 0);
for (int(i) = (1); (i) <= (n); (i)++) now = i, first = 0, dfs2(i, 0, 0);
for (int(i) = (1); (i) <= (n); (i)++)
for (int(j) = (1); (j) <= (n); (j)++)
if (bel[i] != bel[j]) ans -= 1. / (dis[i] + dis[j] + cycle);
printf("%lf", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 1000010, P = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int INF = 0xcfcfcfcf;
const double eps = 1e-9, pi = asin(1) * 2;
inline long long read();
inline int ADD(int a, int b) { return a + b >= P ? a + b - P : a + b; }
inline int MINUS(int a, int b) { return a - b < 0 ? a - b + P : a - b; }
int head[N], ver[M], nxt[M];
int n, m, tot = 1;
inline void add(int x, int y) {
ver[++tot] = y, nxt[tot] = head[x], head[x] = tot;
}
int pos[N], sz = 0, ed = 0;
bool visit[N];
inline bool dfs(int x, int fa) {
visit[x] = true;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == fa) continue;
if (visit[y]) return ed = y, pos[x] = ++sz;
if (dfs(y, x) && y != ed) return pos[x] = ++sz;
}
return visit[x] = false;
}
int f[N], d[N], size[N], son[N], top[N], rt[N], RT = 0;
inline void dfs1(int x, int fa) {
f[x] = fa, d[x] = d[fa] + 1, size[x] = 1, rt[x] = RT;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == fa || pos[y]) continue;
dfs1(y, x);
size[x] += size[y];
if (size[y] > size[son[x]]) son[x] = y;
}
}
inline void dfs2(int x, int t) {
top[x] = t;
if (!son[x]) return;
dfs2(son[x], t);
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (y == f[x] || y == son[x] || pos[y]) continue;
dfs2(y, y);
}
}
inline int lca(int x, int y) {
int fx = top[x], fy = top[y];
while (fx != fy) {
if (d[fx] < d[fy]) swap(x, y), swap(fx, fy);
x = f[fx], fx = top[x];
}
if (d[x] > d[y]) return y;
return x;
}
inline int dis(int x, int y) { return d[x] + d[y] - 2 * d[lca(x, y)]; }
inline long long read() {
long long s = 0;
bool flag = false;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') flag = true;
for (; '0' <= ch && ch <= '9'; ch = getchar())
s = (s << 3) + (s << 1) + (ch ^ '0');
if (flag) return -s;
return s;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int x = read() + 1, y = read() + 1;
add(x, y), add(y, x);
}
dfs(1, 0);
for (int i = 1; i <= n; i++)
if (pos[i]) RT = i, dfs1(i, 0), dfs2(i, i);
double ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (rt[i] == rt[j]) {
ans += 1.0 / (dis(i, j) + 1);
} else {
int x = d[i] + d[j], y = abs(pos[rt[i]] - pos[rt[j]]) - 1,
z = sz - 2 - y;
ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
}
}
printf("%.15lf\n", ans);
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int vis[3010];
vector<int> ne[3010];
int n, siz;
int du[3010];
queue<int> q;
double ans;
void dfs(int u, int siza, int sizb, int top) {
if (du[u] == 2)
sizb++;
else
siza++;
vis[u] = top;
if (sizb == siz)
ans += 1.0 / (siza + 2);
else if (sizb <= 2)
ans += 1.0 / (siza + sizb);
else
ans += 1.0 / (siza + sizb) + 1.0 / (siza + siz - sizb + 2) -
1.0 / (siza + siz);
for (int v : ne[u])
if (vis[v] != top) dfs(v, siza, sizb, top);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
x++, y++;
ne[x].push_back(y);
ne[y].push_back(x);
du[x]++, du[y]++;
}
for (int i = 1; i <= n; i++)
if (du[i] == 1) q.push(i);
while (q.size()) {
int u = q.front();
q.pop();
for (int v : ne[u])
if ((--du[v]) == 1) q.push(v);
}
for (int i = 1; i <= n; i++)
if (du[i] == 2) siz++;
for (int i = 1; i <= n; i++) dfs(i, 0, 0, i);
printf("%.10f\n", ans);
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
void file(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
template <typename Tp>
void read(Tp &x) {
int fh = 1;
char c = getchar();
x = 0;
while (c > '9' || c < '0') {
if (c == '-') {
fh = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
x *= fh;
}
vector<int> G[1000005], nG[1000005];
int n, m;
int ff[1000005];
int fid(int x) { return ff[x] == x ? ff[x] : ff[x] = fid(ff[x]); }
int cycdep[1000005], ffa[1000005], nm;
void dfs0(int x, int pa) {
ffa[x] = pa;
for (auto y : G[x]) {
if (y == pa) continue;
if (ffa[y]) {
cycdep[x] = 1;
for (int yy = ffa[x], nm = 2; yy != x; yy = ffa[yy], ++nm)
cycdep[yy] = nm;
return;
} else
dfs0(y, x);
}
}
long double ans;
void dfs(int x, int pa, int dep, int flg1, int flg2) {
if (x == n + 1) {
for (auto y : nG[x]) {
if (y == pa) continue;
dfs(y, x, dep, pa, y);
}
return;
}
for (auto y : nG[x]) {
if (y == pa) continue;
dfs(y, x, dep + 1, flg1, flg2);
}
if (flg1) {
int a = cycdep[flg1], b = cycdep[flg2];
int aa = abs(a - b), bb = nm - aa;
--aa, --bb;
ans += 1.0 / (dep + aa);
ans += 1.0 / (dep + bb);
ans -= 1.0 / (dep + aa + bb);
} else {
ans += 1.0 / dep;
}
}
signed main() {
int RT, X;
read(n);
for (int i = 1; i <= n; ++i) ff[i] = i;
for (int i = 1, u, v; i <= n; ++i) {
read(u);
read(v);
++u;
++v;
G[u].push_back(v);
G[v].push_back(u);
if (fid(u) == fid(v)) {
RT = u;
X = v;
} else {
ff[fid(u)] = fid(v);
}
}
dfs0(RT, X);
for (int i = 1; i <= n; ++i) {
for (auto y : G[i]) {
if (cycdep[i] && cycdep[y]) continue;
nG[i].push_back(y);
}
}
for (int i = 1; i <= n; ++i) {
if (cycdep[i]) {
nG[n + 1].push_back(i);
nG[i].push_back(n + 1);
++nm;
}
}
for (int i = 1; i <= n; ++i) {
dfs(i, 0, 1, 0, 0);
}
cout << fixed << setprecision(15) << ans << endl;
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void debug(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void debug(T1 e1, T2 e2) {
cout << e1 << "\t" << e2 << endl;
}
template <class T1, class T2, class T3>
void debug(T1 e1, T2 e2, T3 e3) {
cout << e1 << "\t" << e2 << "\t" << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void debug(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void debug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void debug(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << "\t"
<< e6 << endl;
}
template <class T>
void debug(vector<vector<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> > e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(T e[110][110], int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
bool isVowel(char ch) {
ch = tolower(ch);
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
vector<int> adj[3110];
int n;
int col[3110];
int cyclecolor;
void predfs(int node, int par) {
col[node] = node + 1;
int i;
for (i = 0; i < ((int)adj[node].size()); i++) {
int tem = adj[node][i];
if (tem == par) continue;
if (col[tem]) {
cyclecolor = col[node] = col[tem];
continue;
}
predfs(tem, node);
if (col[tem] != (tem + 1)) col[node] = col[tem];
}
}
bool temcol[3110];
int cyclelength;
double ans;
void dfs(int node, int c, int len) {
if (temcol[node]) return;
temcol[node] = true;
ans += (1.0 / len);
if (c > 2 && (len + cyclelength - 2 * c + 2) > 0)
ans += (1.0 * (c - 2)) /
((len - c + cyclelength) * (len + cyclelength - 2 * c + 2));
int i;
for (i = 0; i < ((int)adj[node].size()); i++) {
int tem = adj[node][i];
dfs(tem, c + (cyclecolor == col[tem]), len + 1);
}
}
int main() {
while (cin >> n) {
int i, u, v;
for (i = 1; i <= n; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
predfs(0, -1);
for (i = 0; i < n; i++) cyclelength += (cyclecolor == col[i]);
for (i = 0; i < n; i++) {
memset(temcol, false, sizeof(temcol));
dfs(i, (cyclecolor == col[i]), 1);
}
printf("%.12lf\n", ans);
}
return 0;
}
| 10 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct road {
int x, next;
} r[3005 * 2];
int N, M;
double ans;
int fa[3005], flag;
int st[3005], w, vis[3005], pr[3005];
int deep[3005], lca[3005][3005], rt[3005];
int loop[3005], num[3005], cnt;
int stk[3005], top;
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
void add(int x, int y) {
r[++w].x = y, r[w].next = st[x];
st[x] = w;
}
void Find_loop(int x, int fr) {
int i, j, tmp;
stk[++top] = x, vis[x] = 1;
for (i = st[x]; i; i = r[i].next) {
tmp = r[i].x;
if (tmp == fr) continue;
if (vis[tmp])
if (!num[tmp]) {
for (j = top; j && stk[j + 1] != tmp; j--)
loop[++cnt] = stk[j], num[stk[j]] = cnt;
} else
;
else
Find_loop(tmp, x);
}
top--;
}
void Dfs(int x, int fr) {
int i, tmp;
deep[x] = deep[fr] + 1, pr[x] = fr;
for (i = st[x]; i; i = r[i].next) {
tmp = r[i].x;
if (tmp == fr || num[tmp]) continue;
Dfs(tmp, x);
}
rt[x] = flag;
for (i = 1; i <= N; i++)
if (rt[i] == rt[x])
lca[i][x] = lca[x][i] = ((find(i) == x) ? x : pr[find(i)]);
for (i = st[x]; i; i = r[i].next) {
tmp = r[i].x;
if (tmp == fr || num[tmp]) continue;
fa[find(tmp)] = x;
}
}
int main() {
int i, j;
int fr, to;
double tmp, tt, all;
scanf("%d", &N);
for (i = 1; i <= N; i++) {
fa[i] = i;
scanf("%d %d", &fr, &to);
fr++, to++;
add(fr, to), add(to, fr);
}
Find_loop(1, 0);
for (i = 1; i <= cnt; i++) flag = loop[i], Dfs(loop[i], 0);
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++) {
if (rt[i] == rt[j])
ans += 1.0 / (deep[i] + deep[j] - deep[lca[i][j]] * 2 + 1);
else {
fr = num[rt[i]], to = num[rt[j]];
tmp = deep[i] + deep[j];
tt = abs(fr - to) + 1;
all = tmp + cnt - 2;
ans += 1;
ans -= (tmp - 1) / (double)all;
ans -= ((tt - 2) / all) * ((tmp + cnt - tt - 1) / (tmp + cnt - tt));
ans -= ((cnt - tt) / all) * ((tmp + tt - 3) / (tmp + tt - 2));
}
}
printf("%.10lf\n", ans);
return 0;
}
| 10 |
CPP
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.