text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
struct _ {
ios_base::Init i;
_() {
cin.sync_with_stdio(0);
cin.tie(0);
}
} _;
vector<bool> isOnC;
struct Edge {
int a, b;
};
int t, k;
int n;
int temp = -1;
int cLength = 0;
vector<bool> isMarked;
vector<vector<int> > e;
vector<vector<int> > dist;
double sum = 0.0;
int source = -1;
void dfs(int a, int d, int cD) {
if (dist[source][a] == -1) {
dist[source][a] = d;
dist[a][source] = d;
int x, y, z;
if (cD >= 2) {
x = d - cD + 2;
y = cD - 2;
z = cLength - cD;
} else {
x = d;
y = z = 0;
}
double t = 2.0;
if (source == a) t = 1.0;
;
;
;
;
sum += t * (1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z));
}
isMarked[a] = true;
for (int i = 0; i < e[a].size(); ++i) {
if (!isMarked[e[a][i]]) {
dfs(e[a][i], d + 1, cD + isOnC[e[a][i]]);
}
}
}
void findCycle(int p, int a) {
if (isMarked[a]) {
isOnC[a] = true;
temp = a;
;
cLength++;
return;
}
isMarked[a] = true;
for (int i = 0; i < e[a].size(); ++i) {
if (e[a][i] != p) findCycle(a, e[a][i]);
if (temp == a) {
temp = -1;
return;
} else if (temp != -1) {
;
++cLength;
isOnC[a] = true;
return;
}
}
}
int main() {
cin >> n;
isOnC.assign(n, false);
e.assign(n, vector<int>());
int a, b;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
isMarked.assign(n, false);
temp = -1;
findCycle(-1, 0);
dist.assign(n, vector<int>(n, -1));
for (int i = 0; i < n; ++i) {
source = i;
isMarked.assign(n, false);
dfs(i, 1, isOnC[i]);
}
cout << fixed << setprecision(8) << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long _x = 0;
int _ch = getchar(), _f = 1;
for (; !isdigit(_ch) && (_ch != '-') && (_ch != EOF); _ch = getchar())
;
if (_ch == '-') {
_f = 0;
_ch = getchar();
}
for (; isdigit(_ch); _ch = getchar()) _x = _x * 10 + _ch - '0';
return _f ? _x : -_x;
}
void write(long long _x) {
if (_x >= 10)
write(_x / 10), putchar(_x % 10 + '0');
else
putchar(_x + '0');
}
inline void wrt(long long _x, char _p) {
if (_x < 0) putchar('-'), _x = -_x;
write(_x);
if (_p) putchar(_p);
}
int nx[3005 << 1], to[3005 << 1], hd[3005], cnt;
inline void add(int u, int v) { nx[++cnt] = hd[u], to[cnt] = v, hd[u] = cnt; }
int sta[3005], top;
int in[3005], len, n;
bool vis[3005], flag;
void dfs(int u, int fa) {
sta[++top] = u, vis[u] = 1;
for (int i = hd[u]; i; i = nx[i])
if (to[i] != fa) {
if (!vis[to[i]])
dfs(to[i], u);
else {
flag = 1;
while (sta[top + 1] != to[i]) {
in[sta[top]] = 1, top--, len++;
}
return;
}
if (flag) return;
}
top--;
}
double Ans;
void solve(int x, int y) {
if (y <= 1)
Ans += 1 / double(x);
else {
int Sum = x - y + len;
Ans -= 1 / double(Sum);
Ans += 1 / double(Sum - (y - 2));
Ans += 1 / double(Sum - (len - y));
}
}
void DFS(int u, int len1, int len2) {
vis[u] = 1, solve(len1, len2);
for (int i = hd[u]; i; i = nx[i])
if (!vis[to[i]]) DFS(to[i], len1 + 1, len2 + in[to[i]]);
}
int main() {
n = rd();
for (int i = int(1); i <= (int)(n); i++) {
int x = rd() + 1, y = rd() + 1;
add(x, y), add(y, x);
}
dfs(1, 0);
for (int i = int(1); i <= (int)(n); i++) {
memset(vis, 0, sizeof vis);
DFS(i, 1, in[i]);
}
printf("%.10lf\n", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3000 + 5;
int n;
vector<int> G[maxN];
vector<int> loop;
int no[maxN];
bool vis[maxN];
int stk[maxN], len = 0;
bool DFS(int u, int fa) {
stk[len++] = u;
vis[u] = true;
for (int v : G[u])
if (v != fa) {
if (vis[v]) {
do {
len--;
loop.push_back(stk[len]);
no[stk[len]] = (int)loop.size() - 1;
} while (stk[len] != v);
return true;
} else {
if (DFS(v, u)) return true;
}
}
--len;
return false;
}
double ans = 0;
vector<int> l[maxN];
void Go(int u, int fa) {
l[u].assign(1, 0);
for (int v : G[u])
if (v != fa) {
Go(v, u);
for (int x : l[u])
for (int y : l[v]) {
ans += 1.0 / (x + y + 1 + 1);
}
for (int y : l[v]) l[u].push_back(y + 1);
l[v].clear();
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
memset(vis, 0, sizeof(vis));
memset(no, -1, sizeof(no));
bool foundCycle = DFS(0, -1);
assert(foundCycle);
for (int u : loop) {
for (auto i = G[u].begin(); i != G[u].end(); ++i)
if (no[*i] >= 0) {
G[u].erase(i);
break;
}
for (auto i = G[u].begin(); i != G[u].end(); ++i)
if (no[*i] >= 0) {
G[u].erase(i);
break;
}
Go(u, -1);
}
for (int A : loop)
for (int B : loop) {
int i = no[A], j = no[B];
if (i >= j) continue;
int x = j - i, y = (int)loop.size() + i - j;
for (int u : l[A])
for (int v : l[B]) {
ans += 1.0 / (u + v + x + 1) + 1.0 / (u + v + y + 1) -
1.0 / (u + v + x + y);
}
}
cout << fixed << setprecision(10) << ans * 2.0 + n << endl;
return 0;
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, tot;
const int N = 3005;
int head[N], to[N << 1], nt[N << 1];
inline int read() {
int res = 0;
char ch = getchar();
bool XX = false;
for (; !isdigit(ch); ch = getchar()) (ch == '-') && (XX = true);
for (; isdigit(ch); ch = getchar()) res = (res << 3) + (res << 1) + (ch ^ 48);
return XX ? -res : res;
}
void add(int f, int t) {
to[++tot] = t;
nt[tot] = head[f];
head[f] = tot;
}
namespace solve2 {
int top, tot;
double ans;
int in[N], zhan[N], cir[N], incir[N], belong[N], f[N][15], dep[N];
int findcir(int x, int fa) {
if (in[x]) {
int t;
do {
t = zhan[top--];
incir[t] = 1;
cir[++tot] = t;
} while (x != t);
return 1;
}
zhan[++top] = x;
in[x] = 1;
for (int i = head[x]; i; i = nt[i])
if (to[i] != fa && findcir(to[i], x)) return 1;
in[x] = 0;
--top;
return 0;
}
void dfs(int x, int fa, int c) {
belong[x] = c;
f[x][0] = fa;
dep[x] = dep[fa] + 1;
for (int i = 1; i < 15; ++i) f[x][i] = f[f[x][i - 1]][i - 1];
for (int i = head[x]; i; i = nt[i])
if (!incir[to[i]] && to[i] != fa) dfs(to[i], x, c);
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 14; i >= 0; --i)
if (dep[f[x][i]] >= dep[y]) x = f[x][i];
if (x == y) return x;
for (int i = 14; i >= 0; --i)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
int Dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[LCA(x, y)] + 1; }
int jue(int x) { return x > 0 ? x : -x; }
void work() {
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 (belong[i] == belong[j])
ans += 1.0 / Dis(i, j);
else {
int x = dep[i] + dep[j], y = jue(belong[i] - belong[j]) - 1,
z = tot - 2 - y;
ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
}
printf("%0.7f", ans);
}
} // namespace solve2
int main() {
cin >> n;
for (int i = 1, x, y; i <= n; ++i) {
x = read() + 1;
y = read() + 1;
add(x, y);
add(y, x);
}
solve2::work();
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, tot, top, cnt;
int head[3100], nex[3100 << 1], to[3100 << 1];
int st[3100], deep[3100], cir[3100], inc[3100];
double ans;
vector<int> vec[3100];
void add(int x, int y) {
tot++;
nex[tot] = head[x];
head[x] = tot;
to[tot] = y;
}
void dfs(int x, int y) {
st[++top] = x;
for (int i = head[x]; i; i = nex[i])
if (i != (y ^ 1)) {
if (!deep[to[i]])
deep[to[i]] = deep[x] + 1, dfs(to[i], i);
else if (deep[to[i]] < deep[x]) {
for (int j = top; st[j] != to[i]; j--)
cir[++cnt] = st[j], inc[st[j]] = 1;
cir[++cnt] = to[i];
inc[to[i]] = 1;
}
}
top--;
}
void cal(int x, int y, int tar) {
deep[x] = deep[y] + 1;
vec[tar].push_back(deep[x]);
for (int i = head[x]; i; i = nex[i])
if (to[i] != y && !inc[to[i]]) cal(to[i], x, tar);
}
double get(int v1, int v2, int v3) {
return 1.0 / (v3 + v2) + 1.0 / (v3 + v1) - 1.0 / (v1 + v2 + v3);
}
void dfs1(int x, int y, int dep) {
ans += 1.0 / dep;
for (int i = head[x]; i; i = nex[i])
if (to[i] != y) {
if (inc[x] && inc[to[i]]) continue;
dfs1(to[i], x, dep + 1);
}
}
int main() {
scanf("%d", &n);
tot = 1;
for (int i = 1, x, y; i <= n; i++) {
scanf("%d%d", &x, &y);
x++;
y++;
add(x, y);
add(y, x);
}
deep[1] = 1;
dfs(1, 0);
for (int i = 1; i <= cnt; i++) cal(cir[i], 0, i);
for (int i = 1; i <= cnt; i++)
for (int j = i + 1; j <= cnt; j++) {
int c1 = j - i - 1, c2 = cnt - c1 - 2;
for (int k = 0; k < vec[i].size(); k++)
for (int w = 0; w < vec[j].size(); w++)
ans += get(c1, c2, vec[i][k] + vec[j][w]) * 2;
}
for (int i = 1; i <= n; i++) dfs1(i, 0, 1);
printf("%.7lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
struct Edge {
int src, dst, rev;
int weight;
Edge(int src, int dst, int weight = 1, int rev = -1)
: src(src), dst(dst), weight(weight), rev(rev) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight
: e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
void addBiEdge(vector<vector<Edge> > &g, int from, int to, int w = 1) {
while (g.size() < max(from, to) + 1) g.push_back(vector<Edge>());
g[from].push_back(Edge(from, to, w, g[to].size()));
g[to].push_back(Edge(to, from, w, g[from].size() - 1));
}
void addEdge(vector<vector<Edge> > &g, int from, int to, int w = 1) {
while (g.size() < from + 1) g.push_back(vector<Edge>());
g[from].push_back(Edge(from, to, w));
}
struct IO {
} io;
IO &operator>>(IO &io, int &n) {
scanf("%d", &n);
return io;
}
IO &operator>>(IO &io, unsigned int &n) {
scanf("%u", &n);
return io;
}
IO &operator>>(IO &io, long long &n) {
scanf("%lld", &n);
return io;
}
IO &operator>>(IO &io, unsigned long long &n) {
scanf("%llu", &n);
return io;
}
IO &operator>>(IO &io, double &n) {
scanf("%lf", &n);
return io;
}
IO &operator>>(IO &io, long double &n) {
scanf("%Lf", &n);
return io;
}
IO &operator>>(IO &io, char *c) {
scanf("%s", c);
return io;
}
IO &operator<<(IO &io, const int &n) {
printf("%d", n);
return io;
}
IO &operator<<(IO &io, const unsigned int &n) {
printf("%u", n);
return io;
}
IO &operator<<(IO &io, const long long &n) {
printf("%lld", n);
return io;
}
IO &operator<<(IO &io, const unsigned long long &n) {
printf("%llu", n);
return io;
}
IO &operator<<(IO &io, const double &n) {
printf("%lf", n);
return io;
}
IO &operator<<(IO &io, const long double &n) {
printf("%Lf", n);
return io;
}
IO &operator<<(IO &io, const char c[]) {
printf("%s", c);
return io;
}
template <class T>
IO &operator>>(IO &io, vector<T> &v) {
int n;
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) {
T t;
io >> t;
v.push_back(t);
}
}
int n;
vector<vector<Edge> > g;
int parent[3010], dist[3010], cparent[3010], cdist[3010];
int cycle_pos[3010];
bool vis[3010];
vector<int> v[3010];
vector<int> c;
void find_cycle(int u = 0, int d = 0, int p = -1) {
if (vis[u]) {
int p0 = p, p1 = parent[u];
vector<int> c0, c1;
while (p0 != p1) {
if (dist[p0] > dist[p1]) {
c0.push_back(p0);
p0 = parent[p0];
} else {
c1.push_back(p1);
p1 = parent[p1];
}
}
reverse((c1).begin(), (c1).end());
c.clear();
c.push_back(u);
c.insert(c.end(), (c0).begin(), (c0).end());
c.push_back(p0);
c.insert(c.end(), (c1).begin(), (c1).end());
return;
}
vis[u] = true;
parent[u] = p;
dist[u] = d;
for (typeof((g[u]).begin()) e = (g[u]).begin(); e != (g[u]).end(); ++e) {
if (e->dst == p) continue;
find_cycle(e->dst, d + 1, u);
}
}
double ans = 0.0L;
void dfs(int u, int anc, int p = -1, int d = 0) {
cparent[u] = anc;
cdist[u] = d;
for (typeof((g[u]).begin()) e = (g[u]).begin(); e != (g[u]).end(); ++e) {
if (e->dst == p or cycle_pos[e->dst] >= 0) continue;
dfs(e->dst, anc, u, d + 1);
}
}
void dfs2(int u, int anc, int p = -1, int d = 0) {
ans += 1 / (double)(d + 1);
for (typeof((g[u]).begin()) e = (g[u]).begin(); e != (g[u]).end(); ++e) {
if (e->dst == p or (cycle_pos[e->dst] >= 0 and e->dst != anc)) continue;
dfs2(e->dst, anc, u, d + 1);
}
}
int main() {
io >> n;
g.assign(n, vector<Edge>());
for (int i = 0; i < (int)(n); ++i) {
int a, b;
io >> a >> b;
addBiEdge(g, a, b);
}
memset((vis), 0, sizeof(vis));
memset((cycle_pos), -1, sizeof(cycle_pos));
find_cycle();
for (int i = 0; i < (int)(c.size()); ++i) cycle_pos[c[i]] = i;
for (int i = 0; i < (int)(c.size()); ++i) dfs(c[i], c[i]);
for (int u = 0; u < (int)(n); ++u) {
int u0 = cparent[u];
for (int v = 0; v < (int)(n); ++v) {
int v0 = cparent[v];
if (u0 == v0) continue;
int A = abs(cycle_pos[u0] - cycle_pos[v0]), B = c.size() - A;
A--;
B--;
int s = cdist[u] + cdist[v] + c.size();
ans += 1 / (double)(s - A) + 1 / (double)(s - B) - 1 / (double)s;
}
}
for (int u = 0; u < (int)(n); ++u) dfs2(u, cparent[u]);
printf("%.10lf\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3003;
int n, L, top, cir[N], stk[N], cnt[N], bel[N], dep[N], fa[N];
double ans;
vector<int> nxt[N];
void dfs(int u, int lst) {
dep[u] = dep[lst] + 1, fa[u] = lst;
for (auto v : nxt[u])
if (v != lst) {
if (!dep[v])
dfs(v, u);
else if (dep[v] < dep[u]) {
int now = u;
cir[++L] = now;
do {
now = fa[now], cir[++L] = now;
} while (now != v);
}
}
}
void get(int u) {
stk[++top] = u;
for (auto v : nxt[u])
if (!bel[v]) bel[v] = bel[u], get(v);
}
void DFS(int u, int lst) {
dep[u] = dep[lst] + 1;
for (auto v : nxt[u])
if (bel[v] == bel[u] && v != lst) DFS(v, u);
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
int p, q;
cin >> p >> q;
++p, ++q;
nxt[p].push_back(q);
nxt[q].push_back(p);
}
dfs(1, 0);
for (int i = 1; i <= L; ++i) bel[cir[i]] = i;
for (int i = 1; i <= L; ++i) {
top = 0;
get(cir[i]);
for (int j = 1; j <= top; ++j) {
DFS(stk[j], 0);
for (int k = 1; k <= top; ++k) ++cnt[dep[stk[k]]];
}
DFS(cir[i], 0);
}
for (int i = 1; i <= n; ++i) ans += 1 / (double)i * cnt[i];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (bel[i] != bel[j]) {
int x = abs(bel[i] - bel[j]) - 1, y = L - 2 - x;
ans += 1 / (double)(dep[i] + dep[j] + x) +
1 / (double)(dep[i] + dep[j] + y) -
1 / (double)(dep[i] + dep[j] + x + y);
}
printf("%.10lf", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[6010], n1[6010], h[6010], ee = 0, n;
int pre[6010], cir[6010], iscir[6010], cirtot = 0, tmp[6010], id[6010],
bl[6010], d[6010];
bool vis[3010][3010];
double ans = 0;
void ae(int x, int y) {
p[ee] = y;
n1[ee] = h[x];
h[x] = ee++;
}
void dfs(int u, int fa) {
tmp[u] = 1;
for (int i = h[u]; ~i; i = n1[i]) {
if (cir[1]) return;
if (p[i] == fa || tmp[p[i]] == 2) continue;
pre[p[i]] = u;
if (tmp[p[i]] == 1) {
if (!cir[1]) cir[1] = p[i];
return;
}
dfs(p[i], u);
}
tmp[u] = 2;
}
void dd(int rt, int u, int fa) {
bl[u] = rt;
for (int i = h[u]; ~i; i = n1[i]) {
if (p[i] == fa || iscir[p[i]]) continue;
d[p[i]] = d[u] + 1;
dd(rt, p[i], u);
}
}
void count(int u, int v, int fa, int x, int y) {
int z = d[u] + d[v];
ans +=
(double)2 * ((double)1 / (double)(z + x) + (double)1 / (double)(z + y) -
(double)1 / (double)(x + y + z));
for (int i = h[v]; ~i; i = n1[i]) {
if (iscir[p[i]] || p[i] == fa) continue;
count(u, p[i], v, x, y);
}
}
void count2(int u, int fa, int v, int x, int y) {
count(u, v, 0, x, y);
for (int i = h[u]; ~i; i = n1[i]) {
if (iscir[p[i]] || p[i] == fa) continue;
count2(p[i], u, v, x, y);
}
}
void tr(int u, int fa, int dep) {
ans += (double)1 / (double)dep;
for (int i = h[u]; ~i; i = n1[i]) {
if (p[i] != bl[u] && iscir[p[i]]) continue;
if (p[i] == fa) continue;
tr(p[i], u, dep + 1);
}
}
int main() {
scanf("%d", &n);
int x, y;
memset(h, -1, sizeof(h));
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
++x;
++y;
ae(y, x);
ae(x, y);
}
dfs(1, 0);
iscir[cir[1]] = 1;
x = pre[cir[1]];
while (x != cir[1]) {
cir[++cirtot] = x;
iscir[x] = 1;
x = pre[x];
}
for (int i = 1; i <= cirtot; i++) {
id[cir[i]] = i;
d[cir[i]] = 1;
dd(cir[i], cir[i], 0);
}
for (int i = 1; i <= cirtot; i++)
for (int j = i + 1; j <= cirtot; j++)
count2(cir[i], 0, cir[j], j - i - 1, cirtot - (j - i + 1));
for (int i = 1; i <= n; i++) tr(i, 0, 1);
printf("%.10lf\n", (double)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
register T sum = 0;
register char cc = getchar();
int sym = 1;
while (cc != '-' && (cc > '9' || cc < '0')) cc = getchar();
if (cc == '-') sym = -1, cc = getchar();
sum = sum * 10 + cc - '0';
cc = getchar();
while (cc >= '0' && cc <= '9') sum = sum * 10 + cc - '0', cc = getchar();
return sym * sum;
}
template <typename T>
inline T read(T &a) {
a = read<T>();
return a;
}
template <typename T, typename... Others>
inline void read(T &a, Others &...b) {
a = read(a);
read(b...);
}
struct Edge {
int v;
Edge *next;
Edge(int a = 0, Edge *b = NULL) {
v = a;
next = b;
}
} * head[3010];
int n, cnt, tp, sta[3010], in[3010], cir[3010], dep[3010], vis[3010], rnk[3010],
col[3010];
double ans;
bool dfs1(int k, int fa) {
sta[++tp] = k;
vis[k] = true;
for (Edge *i = head[k]; i != NULL; i = i->next) {
if (i->v == fa) continue;
if (vis[i->v]) {
int x = 0;
while (tp && x != i->v) {
x = sta[tp--];
cir[++cnt] = x;
rnk[x] = cnt;
in[x] = true;
}
return true;
}
if (dfs1(i->v, k)) return true;
}
vis[k] = false;
tp -= 1;
return false;
}
void dfs2(int k, int fa, int rt) {
col[k] = rt;
dep[k] = dep[fa] + 1;
for (Edge *i = head[k]; i != NULL; i = i->next)
if (i->v != fa && !in[i->v]) dfs2(i->v, k, rt);
}
void dfs3(int k, int fa, int dis) {
ans += 1. / dis;
for (Edge *i = head[k]; i != NULL; i = i->next)
if (i->v != fa && (i->v == col[k] || !in[i->v])) dfs3(i->v, k, dis + 1);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) {
int x, y;
read(x, y);
x += 1, y += 1;
head[x] = new Edge(y, head[x]);
head[y] = new Edge(x, head[y]);
}
dfs1(1, 0);
for (int i = 1; i <= cnt; i++) dfs2(cir[i], 0, cir[i]);
for (int i = 1; i <= n; i++) {
dfs3(i, 0, 1);
for (int j = 1; j <= n; j++) {
if (col[i] == col[j]) continue;
ans += 1. / (dep[i] + dep[j] + abs(rnk[col[i]] - rnk[col[j]]) - 1);
ans += 1. / (dep[i] + dep[j] + cnt - abs(rnk[col[i]] - rnk[col[j]]) - 1);
ans -= 1. / (dep[i] + dep[j] + cnt - 2);
}
}
printf("%.10lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int head[3010];
int from[3010];
int to[6010];
int nex[6010];
int dep[3010];
int q[3010];
int cnt;
int vis[3010];
int bel[3010];
double ans;
int tot;
int x, y, n;
int f[3010][15];
void add(int x, int y) {
nex[++tot] = head[x];
head[x] = tot;
to[tot] = y;
}
bool dfs(int x, int fa) {
vis[x] = 1;
for (int i = head[x]; i; i = nex[i]) {
if (to[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], x)) {
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 <= 13; 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 <= 13; i++) {
if (d & (1 << i)) {
x = f[x][i];
}
}
if (x == y) {
return x;
}
for (int i = 13; 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);
add(y, x);
}
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);
}
|
#include <bits/stdc++.h>
int fr[3010], ne[6010], v[6010], bs = 0;
void addb(int a, int b) {
v[bs] = b;
ne[bs] = fr[a];
fr[a] = bs++;
}
int bk[3010], sd[3010], hu[3010], fa[3010], sl = 0;
void dfs1(int u, int f) {
bk[u] = 1;
fa[u] = f;
sd[u] = sd[f] + 1;
for (int i = fr[u]; i != -1; i = ne[i]) {
if (v[i] == f) continue;
if (bk[v[i]]) {
if (sd[v[i]] < sd[u]) {
int t = u;
while (1) {
hu[sl++] = t;
if (t == v[i]) break;
t = fa[t];
}
}
} else
dfs1(v[i], u);
}
}
int hd[3010], ro[3010], lc[3010][3010], wz[3010];
void dfs2(int u, int f, int rt) {
fa[u] = f;
ro[u] = rt;
sd[u] = sd[f] + 1;
for (int i = fr[u]; i != -1; i = ne[i]) {
if (v[i] == f || hd[v[i]]) continue;
dfs2(v[i], u, rt);
}
}
int dfs3(int a, int b) {
if (a == b) return lc[a][b] = a;
if (lc[a][b]) return lc[a][b];
if (sd[a] > sd[b])
lc[a][b] = dfs3(fa[a], b);
else
lc[a][b] = dfs3(a, fa[b]);
return lc[a][b];
}
int getdis(int a, int b) {
int l = dfs3(a, b);
return sd[a] + sd[b] - sd[l] * 2 + 1;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) fr[i] = -1;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a += 1;
b += 1;
addb(a, b);
addb(b, a);
}
dfs1(1, 0);
for (int i = 0; i < sl; i++) {
hd[hu[i]] = 1;
wz[hu[i]] = i;
}
for (int i = 0; i < sl; i++) dfs2(hu[i], 0, hu[i]);
double ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (ro[i] == ro[j])
ans += 1.0 / getdis(i, j);
else {
int a = sd[i] + sd[j];
int b = wz[ro[i]] - wz[ro[j]];
if (b < 0) b = -b;
b -= 1;
int c = sl - 2 - b;
ans += 1.0 / (a + b);
ans += 1.0 / (a + c);
ans -= 1.0 / (a + b + c);
}
}
}
printf("%.10lf", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3010;
double ans = 0;
int n, l[maxn], e = 0;
int deg[maxn], dep[maxn], a[maxn], tot;
vector<int> sub[maxn], son[maxn];
struct Edge {
int v, x;
} E[maxn << 1];
inline void addEdge(int u, int v) { E[e].v = v, E[e].x = l[u], l[u] = e++; }
void dfs(int u) {
sub[u].push_back(u);
for (int i = 0; i < son[u].size(); i++) {
int v = son[u][i];
dep[v] = dep[u] + 1;
dfs(v);
for (int _1 = 0; _1 < sub[u].size(); _1++) {
for (int _2 = 0; _2 < sub[v].size(); _2++) {
int x = sub[u][_1], y = sub[v][_2];
int d = dep[x] + dep[y] - 2 * dep[u] + 1;
ans += double(1) / d;
}
}
for (int _ = 0; _ < sub[v].size(); _++) sub[u].push_back(sub[v][_]);
}
}
int main() {
memset(l, -1, sizeof(l));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int u, v;
scanf("%d%d", &u, &v);
++u, ++v;
addEdge(u, v), addEdge(v, u);
++deg[u], ++deg[v];
}
queue<int> Q;
for (int i = 1; i <= n; i++)
if (deg[i] == 1) Q.push(i);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int p = l[u]; p >= 0; p = E[p].x) {
int v = E[p].v;
if (deg[v] >= 2) {
--deg[v];
if (deg[v] == 1) Q.push(v);
son[v].push_back(u);
}
}
}
for (int i = 1; i <= n; i++) {
if (deg[i] >= 2) {
int u = i, last = 0;
do {
for (int p = l[u]; p >= 0; p = E[p].x) {
int v = E[p].v;
if (deg[v] >= 2 && v != last) {
last = u;
u = v;
break;
}
}
a[++tot] = u;
} while (u != i);
break;
}
}
for (int i = 1; i <= n; i++) {
if (deg[i] >= 2) {
dfs(i);
}
}
for (int i = 1; i <= tot; i++) {
for (int j = i + 1; j <= tot; j++) {
for (int _1 = 0; _1 < sub[a[i]].size(); _1++) {
for (int _2 = 0; _2 < sub[a[j]].size(); _2++) {
int u = sub[a[i]][_1], v = sub[a[j]][_2];
ans += double(1) / (dep[u] + dep[v] + j - i + 1);
ans += double(1) / (dep[u] + dep[v] + tot - j + i + 1);
ans -= double(1) / (dep[u] + dep[v] + tot);
}
}
}
}
ans = ans * 2 + n;
printf("%.10lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3005;
struct Node {
int to, id;
Node() = default;
Node(int a, int b) : to(a), id(b) {}
};
vector<Node> v[MAXN];
int vis[MAXN], st[MAXN], tt, flag;
int siz[MAXN], dep[MAXN], fa[MAXN];
int top[MAXN], son[MAXN], col[MAXN];
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;
}
void dfs_cir(int x, int fa) {
vis[x] = 1;
for (auto y : v[x]) {
if (y.id == fa) continue;
if (vis[y.to]) {
flag = y.to;
st[++tt] = x;
return;
}
dfs_cir(y.to, y.id);
if (flag == -1) {
vis[x] = 0;
return;
}
if (flag) {
st[++tt] = x;
flag == x && (flag = -1);
return;
}
}
}
void dfs_son(int x, int fath) {
siz[x] = 1;
fa[x] = fath;
col[x] = col[fath];
dep[x] = dep[fath] + 1;
for (auto y : v[x]) {
if (vis[y.to]) continue;
if (y.to == fath) continue;
dfs_son(y.to, x), siz[x] += siz[y.to];
if (siz[y.to] > siz[son[x]]) son[x] = y.to;
}
}
void dfs_chain(int x, int tp) {
top[x] = tp;
if (son[x]) dfs_chain(son[x], tp);
for (auto y : v[x]) {
if (vis[y.to]) continue;
if (y.to == fa[x] || y.to == son[x]) continue;
dfs_chain(y.to, y.to);
}
}
inline int query_lca(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
inline int query_dis(int x, int y) {
int lca = query_lca(x, y);
return dep[x] + dep[y] - dep[lca] * 2 + 1;
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
int x = read() + 1, y = read() + 1;
v[x].push_back(Node(y, i));
v[y].push_back(Node(x, i));
}
dfs_cir(1, 0);
for (int i = 1; i <= tt; i++)
col[0] = i, dfs_son(st[i], 0), dfs_chain(st[i], st[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 / query_dis(i, j);
else {
int x = dep[i] + dep[j], y = abs(col[i] - col[j]) - 1, z = tt - y - 2;
ans += 1.0 / (x + y) + 1.0 / (x + z) - 1.0 / (x + y + z);
}
}
printf("%.15lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> depc[3300];
vector<int> adj[3300];
int dep[3300], pos[3300], fa[3300], subsz[3300];
vector<int> st, cycle;
double comprob(int cycleA, int cycleB, int tree1, int tree2) {
return 2.0 / (cycleA + tree1 + tree2 + 1) +
2.0 / (cycleB + tree1 + tree2 + 1) -
2.0 / (cycleA + cycleB + tree1 + tree2);
}
double simprob(int dist) { return 2.0 / (dist + 1); }
bool findcycle(int x, int d) {
assert(d == st.size());
if (dep[x] >= 0) {
if (dep[x] == d - 2) return 0;
for (int i = dep[x]; i < d; i++) cycle.push_back(st[i]);
return 1;
}
dep[x] = d;
st.push_back(x);
for (int i = 0; i < adj[x].size(); i++)
if (findcycle(adj[x][i], d + 1)) return 1;
st.pop_back();
dep[x] = -2;
return 0;
}
void buildtree(int x) {
subsz[x] = 1;
for (int i = 0; i < adj[x].size(); i++)
if (adj[x][i] != fa[x] && pos[adj[x][i]] < 0) {
fa[adj[x][i]] = x;
buildtree(adj[x][i]);
subsz[x] += subsz[adj[x][i]];
}
}
double answertree(int x) {
double res = 0;
int maxdep = 0;
for (int i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != fa[x] && pos[adj[x][i]] < 0) {
res += answertree(adj[x][i]);
maxdep = max(maxdep, (int)depc[adj[x][i]].size());
}
}
depc[x].resize(maxdep + 1);
depc[x][0]++;
for (int i = 0; i < adj[x].size(); i++)
if (adj[x][i] != fa[x] && pos[adj[x][i]] < 0) {
for (int oldd = 1; oldd <= depc[adj[x][i]].size(); oldd++)
for (int newd = 0; newd <= maxdep; newd++)
res +=
simprob(oldd + newd) * depc[x][newd] * depc[adj[x][i]][oldd - 1];
for (int oldd = 1; oldd <= depc[adj[x][i]].size(); oldd++)
depc[x][oldd] += depc[adj[x][i]][oldd - 1];
depc[adj[x][i]].clear();
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(dep, -1, sizeof(dep));
memset(pos, -1, sizeof(pos));
memset(fa, -1, sizeof(fa));
findcycle(0, 0);
for (int i = 0; i < cycle.size(); i++) pos[cycle[i]] = i;
for (int i = 0; i < cycle.size(); i++) buildtree(cycle[i]);
double res = n;
for (int i = 0; i < cycle.size(); i++) res += answertree(cycle[i]);
for (int i = 0; i < cycle.size(); i++)
for (int j = i + 1; j < cycle.size(); j++) {
for (int di = 0; di < depc[cycle[i]].size(); di++)
for (int dj = 0; dj < depc[cycle[j]].size(); dj++)
res += comprob(j - i, cycle.size() - j + i, di, dj) *
depc[cycle[i]][di] * depc[cycle[j]][dj];
}
printf("%.8lf\n", res);
return 0;
}
|
#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;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, n;
} e[11000];
int fi[11000], di[11000], q[11000];
bool used[11000], in[11000];
int n, tot, len;
double ans;
inline void insert(const int& x, const int& y) {
e[++tot] = (node){y, fi[x]}, fi[x] = tot;
}
void dfs(int x, int l1, int l2) {
used[x] = true;
if (l2 <= 1)
ans += 1.0 / l1;
else
ans += 1.0 / l1 + 1.0 / (l1 - l2 + len - l2 + 2) - 1.0 / (l1 - l2 + len);
for (int i = fi[x]; i != -1; i = e[i].n)
if (!used[e[i].t]) dfs(e[i].t, l1 + 1, l2 + in[e[i].t]);
}
int main(void) {
scanf("%d", &n), fill(fi, fi + n + 1, -1), tot = 1;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y), x++, y++;
insert(x, y), insert(y, x), di[x]++, di[y]++;
}
int h = 1, t = 0;
for (int i = 1; i <= n; i++)
if (di[i] == 1) q[++t] = i;
while (h <= t) {
for (int i = fi[q[h]]; i != -1; i = e[i].n)
if ((--di[e[i].t]) == 1) q[++t] = e[i].t;
h++;
}
len = n - t;
for (int i = 1; i <= n; i++)
if (di[i] > 1) in[i] = true;
for (int i = 1; i <= n; i++)
fill(used, used + n + 1, false), dfs(i, 1, in[i]);
printf("%.8lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
using namespace std;
namespace _c {
const double pi = acos(-1.0);
namespace min {
const int i8 = -128;
const int i16 = -32768;
const int i = -2147483647 - 1;
const long long l = -9223372036854775807LL - 1;
} // namespace min
namespace max {
const int i8 = 127;
const int i16 = 32767;
const int i = 2147483647;
const long long l = 9223372036854775807LL;
} // namespace max
} // namespace _c
namespace _f {
template <typename T>
inline const T gcd(T m, T n) {
while (n != 0) {
T t = m % n;
m = n;
n = t;
}
return m;
}
template <typename T>
inline const T max(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline const T min(const T &a, const T &b) {
return a < b ? a : b;
}
template <typename T>
inline const T abs(const T &a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T pow(T a, T b) {
T res = 1;
while (b > 0) {
if (b & 1) {
res = res * a;
}
a = a * a;
b >>= 1;
}
return res;
}
template <typename T>
inline T pow(T a, T b, const T &mod) {
a %= mod;
T res = 1;
while (b > 0) {
if (b & 1) {
res = res * a % mod;
}
a = a * a % mod;
b >>= 1;
}
return res % mod;
}
} // namespace _f
namespace io {
template <typename T>
inline void read(T &t) {
register T res = 0, neg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = -1;
}
}
for (; isdigit(c); c = getchar()) {
res = res * 10 + c - '0';
}
t = res * neg;
}
inline int in() {
register int T;
read(T);
return T;
}
inline long long in_ll() {
register long long T;
read(T);
return T;
}
} // namespace io
int i, j, k, n, m, t, r, flag, chang, num, x, y;
int a[6010], nxt[6010], head[6010], F[6010], f[6010], g[6010];
double an;
inline void add(int x, int y) {
a[++t] = y, nxt[t] = head[x], head[x] = t;
a[++t] = x, nxt[t] = head[y], head[y] = t;
}
void dfs(int x, int y) {
int v;
if (flag) {
return;
}
f[x] = 1;
g[++r] = x;
for (v = head[x]; v; v = nxt[v]) {
int A = a[v];
if (A == y) {
continue;
}
if (flag) {
return;
}
if (f[A]) {
for (; g[r] != A; r--) {
F[g[r]] = 1, chang++;
}
F[A] = 1;
chang++;
flag = 1;
return;
}
dfs(A, x);
}
r--;
}
inline void get(double y, double z) {
if (z <= 1) {
an += 1 / y;
} else {
double x = y - z + chang;
an -= 1 / x;
if (z >= 2) {
an += 1 / (x - (z - 2));
}
if (z <= chang) {
an += 1 / (x - (chang - z));
}
}
}
void Dfs(int x, int y, int z) {
int v;
f[x] = num;
get(y, z);
for (v = head[x]; v; v = nxt[v]) {
if (f[a[v]] != num) {
Dfs(a[v], y + 1, z + F[a[v]]);
}
}
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &x, &y), add(x + 1, y + 1);
}
dfs(1, 0);
num = 1;
for (i = 1; i <= n; i++) {
num++;
Dfs(i, 1, F[i]);
}
printf("%.12lf\n", an);
return 0;
}
|
#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);
}
|
#include <bits/stdc++.h>
using std::cerr;
using std::endl;
const int N = 3005;
int n, dep[N], stk[N], top, on[N];
int circle_size;
double ans;
std::vector<int> G[N];
bool find_circle(int x, int fa) {
dep[x] = dep[fa] + 1;
stk[++top] = x;
for (int y : G[x]) {
if (y == fa) continue;
if (!dep[y]) {
if (find_circle(y, x)) return 1;
} else {
circle_size = dep[x] - dep[y] + 1;
for (int z = 0; y != z; --top) {
z = stk[top];
on[z] = 1;
}
return 1;
}
}
return 0;
}
int vis[N], st;
void dfs(int x, int a, int b) {
vis[x] = 1;
if (x != st) {
double tmp = 0;
if (b == 0) {
tmp = 1.0 / (a + 1);
} else {
int na = a + 2, nb = b - 1, nc = circle_size - 2 - nb;
tmp = 1.0 / (na + nb) + 1.0 / (na + nc) - 1.0 / (na + nb + nc);
}
ans += tmp;
}
for (int y : G[x]) {
if (vis[y]) continue;
int na = a, nb = b;
if (on[x] && on[y])
++nb;
else
++na;
dfs(y, na, nb);
}
}
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) {
int x, y;
std::cin >> x >> y;
++x, ++y;
G[x].push_back(y);
G[y].push_back(x);
}
find_circle(1, 0);
for (int i = 1; i <= n; ++i) {
memset(vis, 0, sizeof(vis));
st = i;
dfs(i, 0, 0);
}
ans += n;
printf("%.12lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 3010;
struct Edge {
int to, nxt;
} edge[Maxn << 1];
int anc[12][Maxn];
int fa[Maxn];
int first[Maxn];
int ring[Maxn];
int dep[Maxn];
int tree[Maxn];
int te = 1, n, tp;
int ringlen, ban1, ban2;
int ringst;
void adde(int x, int y) {
edge[++te] = Edge{y, first[x]};
first[x] = te;
}
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
void getring(int x, int pre) {
ring[++tp] = x;
for (int i = first[x]; i && !ringlen; i = edge[i].nxt) {
if (i == (pre ^ 1)) continue;
int to = edge[i].to;
if (to == ringst) {
ringlen = tp;
return;
}
getring(to, i);
}
--tp;
}
void dfs_tree(int x, int id) {
tree[x] = id;
dep[x] = dep[anc[0][x]] + 1;
for (int i = first[x]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (to == anc[0][x] || to == ban1 || to == ban2) continue;
anc[0][to] = x;
dfs_tree(to, id);
}
}
int getlca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int k = 11; k >= 0; k--)
if (dep[anc[k][x]] >= dep[y]) x = anc[k][x];
if (x == y) return x;
for (int k = 11; k >= 0; k--)
if (anc[k][x] != anc[k][y]) x = anc[k][x], y = anc[k][y];
return anc[0][x];
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) fa[i] = i;
for (int x, y, i = 1; i <= n; ++i) {
cin >> x >> y;
x++;
y++;
adde(x, y);
adde(y, x);
int pa = getfa(x), pb = getfa(y);
if (pa == pb) ringst = x;
fa[pa] = pb;
}
getring(ringst, 0);
ring[0] = ring[ringlen];
ring[ringlen + 1] = ring[1];
for (int i = 1; i <= ringlen; ++i) {
int x = ring[i];
ban1 = ring[i - 1], ban2 = ring[i + 1];
dfs_tree(x, i);
}
for (int k = 1; k <= 11; k++)
for (int i = 1; i <= n; i++) anc[k][i] = anc[k - 1][anc[k - 1][i]];
double ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) {
if (tree[i] == tree[j]) {
int lca = getlca(i, j);
int len = dep[i] + dep[j] - (dep[lca] << 1);
ans += 1.0 / (len + 1);
} else {
int len = dep[i] + dep[j];
int nd1 = tree[i], nd2 = tree[j];
int lenx =
nd1 - nd2 + ringlen > ringlen ? nd1 - nd2 : nd1 - nd2 + ringlen;
int leny =
nd2 - nd1 + ringlen > ringlen ? nd2 - nd1 : nd2 - nd1 + ringlen;
ans += 1.0 / (len + lenx - 1) + 1.0 / (len + leny - 1) -
1.0 / (len + lenx - 1 + leny - 1);
}
}
cout << fixed << setprecision(10) << ans + n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long INF = ~0LLU >> 1;
int rd() { return RAND_MAX == 32767 ? ((rand() << 15) ^ rand()) : rand(); }
template <class T>
void Read_T(T &x) {
char ch;
while ((ch = getchar()) && (ch < '0' || ch > '9'))
;
x = ch - '0';
while ((ch = getchar()) && ch >= '0' && ch <= '9') x = x * 10 + ch - '0';
}
template <class T>
void Read_S(T &x) {
char opt, ch = 1;
while ((opt = ch) && (ch = getchar()) && (ch < '0' || ch > '9'))
;
x = ch - '0';
while ((ch = getchar()) && ch >= '0' && ch <= '9') x = x * 10 + ch - '0';
if (opt == '-') x = -x;
}
const int maxn = 3010;
int n, m, cnt, pos, tal;
int p[maxn], col[maxn], cir[maxn], ins[maxn];
double res;
vector<int> G[maxn];
void Dfs(int t, int fa) {
p[t] = fa;
ins[t] = 1;
for (__typeof(G[t].begin()) e = G[t].begin(); e != G[t].end(); e++)
if (*e == fa)
continue;
else if (!ins[*e])
Dfs(*e, t);
else if (pos == -1) {
pos = t;
tal = *e;
}
}
void Color(int t, int p, int c) {
col[t] = c;
for (__typeof(G[t].begin()) e = G[t].begin(); e != G[t].end(); e++)
if (*e != p && ins[*e] == -1) Color(*e, t, c);
}
void Search(int t, int p, int dep) {
if (col[t] == col[cnt])
res += 1.0 / dep;
else {
int ret0 = abs(ins[col[t]] - ins[col[cnt]]) - 1;
int ret1 = m - 2 - ret0;
int d = dep - ret0;
res += 1.0 / (d + ret0) + 1.0 / (d + ret1) - 1.0 / (d + ret0 + ret1);
}
for (__typeof(G[t].begin()) e = G[t].begin(); e != G[t].end(); e++)
if (*e != p) Search(*e, t, dep + 1);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
memset(ins, 0, sizeof(ins));
pos = -1;
Dfs(0, -1);
m = 0;
memset(ins, -1, sizeof(ins));
for (int i = pos; i != tal; i = p[i]) {
cir[m] = i;
ins[i] = m++;
}
cir[m] = tal;
ins[tal] = m++;
for (int i = 0; i < m; i++) Color(cir[i], -1, cir[i]);
for (__typeof(G[cir[0]].begin()) e = G[cir[0]].begin(); e != G[cir[0]].end();
e++)
if (*e == cir[m - 1]) {
G[cir[0]].erase(e);
break;
}
for (__typeof(G[cir[m - 1]].begin()) e = G[cir[m - 1]].begin();
e != G[cir[m - 1]].end(); e++)
if (*e == cir[0]) {
G[cir[m - 1]].erase(e);
break;
}
res = 0;
for (cnt = 0; cnt < n; cnt++) Search(cnt, -1, 1);
cout << fixed << setprecision(9) << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int cnt = 0, st[3010] = {0};
struct line {
int to, next;
} a[6010];
inline void add(int &x, int &y) {
a[++cnt].to = y;
a[cnt].next = st[x];
st[x] = cnt;
}
int vis[3010], check = 0, st_p, cir_size;
stack<int> ge;
void dfs(int x, int fa) {
ge.push(x);
vis[x] = 1;
for (int i = st[x]; i; i = a[i].next) {
if (vis[a[i].to] && a[i].to != fa) {
st_p = a[i].to;
check = 1;
return;
} else if (!vis[a[i].to]) {
dfs(a[i].to, x);
}
if (check) return;
}
ge.pop();
}
int in_cir[3010], pl[3010];
int depth, dep[3010], anc[3010][20], root[3001];
void dfs2(int &rt, int x) {
root[x] = rt;
for (int i = st[x]; i; i = a[i].next) {
if (!in_cir[a[i].to] && a[i].to ^ anc[x][0]) {
anc[a[i].to][0] = x;
dep[a[i].to] = dep[x] + 1;
dfs2(rt, a[i].to);
}
}
}
inline void get_anc() {
for (int i = 1; i <= depth; i++) {
for (int j = 1; j <= n; j++) {
anc[j][i] = anc[anc[j][i - 1]][i - 1];
}
}
}
inline int get_lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int tmp1 = dep[x] - dep[y], tmp2 = 0, ret = 0;
ret += tmp1;
while (tmp1) {
if (tmp1 & 1) x = anc[x][tmp2];
tmp1 >>= 1;
tmp2++;
}
if (x == y) return ret + 1;
ret += 2;
for (int i = depth; i >= 0; i--) {
if (anc[x][i] ^ anc[y][i]) {
ret += 2 * pow(2, i);
x = anc[x][i];
y = anc[y][i];
}
}
return ret + 1;
}
int roun[3001];
double ans = 0.0;
int main() {
ios::sync_with_stdio(0);
cin >> n;
depth = log2(n) + 1;
n++;
for (int i = 1; i ^ n; i++) {
int x, y;
cin >> x >> y;
x++, y++;
add(x, y);
add(y, x);
}
dfs(1, 0);
while (true) {
in_cir[ge.top()] = 1;
cir_size++;
pl[ge.top()] = cir_size;
roun[cir_size] = ge.top();
if (ge.top() == st_p) break;
ge.pop();
}
for (int i = 1; i <= cir_size; i++) {
dep[roun[i]] = 0;
dfs2(roun[i], roun[i]);
}
get_anc();
for (int i = 1; i ^ n; i++) {
for (int j = 1; j ^ n; j++) {
if (root[i] == root[j]) {
ans += 1.0 / get_lca(i, j);
} else {
int x = max(pl[root[i]], pl[root[j]]),
y = min(pl[root[i]], pl[root[j]]);
int x2 = dep[i] + 1, y2 = dep[j] + 1;
ans += 1.0 / (x2 + y2 + x - y - 1) +
1.0 / (x2 + y2 + cir_size - x + y - 1) -
1.0 / (x2 + y2 + cir_size - 2);
}
}
}
printf("%.10lf", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
void Get_Val(int &Ret) {
Ret = 0;
char ch;
while (ch = getchar(), ch > '9' || ch < '0')
;
do {
(Ret *= 10) += ch - '0';
} while (ch = getchar(), ch >= '0' && ch <= '9');
}
const int Max_N(3050);
namespace UFS {
int Father[Max_N];
int Get_Father(const int &x) {
return Father[x] == x ? x : Father[x] = Get_Father(Father[x]);
}
} // namespace UFS
int N, Head[Max_N], Total, To[Max_N << 1], Next[Max_N << 1], Deep[Max_N];
int Tot, circle[Max_N], root[Max_N];
inline void Add_Edge(const int &s, const int &t) {
++Total, To[Total] = t, Next[Total] = Head[s], Head[s] = Total;
}
void init() {
Get_Val(N);
for (int i = 1; i <= N; ++i) UFS::Father[i] = i;
for (int i = 1, a, b; i <= N; ++i) {
Get_Val(a), Get_Val(b), ++a, ++b;
if (UFS::Get_Father(a) != UFS::Get_Father(b)) {
Add_Edge(a, b), Add_Edge(b, a);
UFS::Father[UFS::Get_Father(a)] = UFS::Get_Father(b);
} else
circle[0] = a, circle[N + 1] = b;
}
}
void dfs(const int &u) {
for (int i = Head[u], v; i; i = Next[i])
if (!root[v = To[i]]) root[v] = root[u], Deep[v] = Deep[u] + 1, dfs(v);
}
int Pre[Max_N];
void prepare() {
queue<int> Q;
Q.push(circle[0]), Pre[circle[0]] = -1;
int u, v;
while (Q.size()) {
u = Q.front(), Q.pop();
for (int i = Head[u], v; i; i = Next[i])
if (!Pre[v = To[i]]) Pre[v] = u, Q.push(v);
}
u = circle[N + 1];
while (u != -1) circle[root[u] = ++Tot] = u, u = Pre[u];
for (int i = 1; i <= Tot; ++i) Deep[u = circle[i]] = 1, dfs(u);
}
double Ans;
void dfs(const int &u, const int &dis) {
Pre[u] = 1;
Ans += 1.0 / (dis * 1.0);
for (int i = Head[u], v; i; i = Next[i])
if (!Pre[v = To[i]] && root[u] == root[v]) dfs(v, dis + 1);
}
inline int Abs(const int &x) { return x >= 0 ? x : -x; }
void work() {
for (int u = 1; u <= N; ++u) {
memset(Pre, 0, sizeof(Pre)), dfs(u, 1);
for (int v = 1, a, b; v <= N; ++v)
if (root[u] != root[v]) {
a = Abs(root[u] - root[v]), b = Tot - Abs(root[u] - root[v]);
Ans += 1.0 / (Deep[u] + Deep[v] + a - 1);
Ans += 1.0 / (Deep[u] + Deep[v] + b - 1);
Ans -= 1.0 / (Deep[u] + Deep[v] + Tot - 2);
}
}
printf("%.10lf", Ans);
}
int main() {
init();
prepare();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, y, pa[3333], rt[3333], dep[3333], dist[3333], len, pos[3333];
vector<int> g[3333], cycle;
bool used[3333], f, in_cycle[3333];
double ans, a, b, c, d;
void dfs(int i, int fa) {
used[i] = 1;
pa[i] = fa;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa) continue;
if (used[to]) {
if (f) continue;
f = 1;
int cur = i;
while (cur != to) {
cycle.push_back(cur);
cur = pa[cur];
}
cycle.push_back(cur);
continue;
}
dfs(to, i);
}
}
void precalc(int i, int fa, int root, int depth) {
rt[i] = root;
dep[i] = depth;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa || in_cycle[to]) continue;
precalc(to, i, root, depth + 1);
}
}
void proc(int i, int fa, int depth, int pt) {
dist[i] = depth;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
if (to == fa || (in_cycle[to] && to != pt)) continue;
proc(to, i, depth + 1, pt);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
x++;
y++;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
for (int i = 0; i < cycle.size(); i++) in_cycle[cycle[i]] = 1;
for (int i = 0; i < cycle.size(); i++) {
pos[cycle[i]] = i;
}
for (int i = 0; i < cycle.size(); i++) {
precalc(cycle[i], 0, cycle[i], 0);
}
len = cycle.size();
for (int i = 1; i <= n; i++) {
memset(dist, 0, sizeof(dist));
proc(i, 0, 0, rt[i]);
for (int j = 1; j <= n; j++) {
if (rt[i] == rt[j]) {
ans += 1.00 / (double)(dist[j] + 1);
} else {
c = (double)dep[i];
d = (double)dep[j];
a = (double)abs(pos[rt[i]] - pos[rt[j]]);
b = (double)(len - (int)a);
ans += (1.00 / (a + c + d + 1.00) + 1.00 / (b + c + d + 1.00) -
1.00 / (a + b + c + d));
}
}
}
printf("%.9lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, rt, bel[3100], dis[3100];
int cnt, q[3100], num[3100], fa[3100];
bool flag, vis[3100];
int edgenum, vet[6100], Next[6100], Head[3100];
double ans;
void addedge(int u, int v) {
vet[++edgenum] = v;
Next[edgenum] = Head[u];
Head[u] = edgenum;
}
void getcycle(int u) {
vis[u] = true;
for (int e = Head[u]; e; e = Next[e]) {
int v = vet[e];
if (v == fa[u]) continue;
if (vis[v]) {
if (!flag) {
flag = true;
int t = u;
while (t != v) {
q[++cnt] = t;
num[t] = cnt;
t = fa[t];
}
q[++cnt] = v;
num[v] = cnt;
}
} else
fa[v] = u, getcycle(v);
}
}
void dfs(int u) {
bel[u] = rt;
vis[u] = true;
for (int e = Head[u]; e; e = Next[e])
if (!vis[vet[e]]) {
dis[vet[e]] = dis[u] + 1;
dfs(vet[e]);
}
}
void solve(int u, int dep) {
vis[u] = true;
if (u != rt) {
if (bel[u] == bel[rt])
ans += 1.0 / dep;
else {
int a = dis[rt] + dis[u], b = abs(num[bel[u]] - num[bel[rt]]) - 1,
c = cnt - 2 - b;
ans += 1.0 / (a + b) + 1.0 / (a + c) - 1.0 / (a + b + c);
}
}
for (int e = Head[u]; e; e = Next[e])
if (!vis[vet[e]]) solve(vet[e], dep + 1);
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &u, &v);
u++;
v++;
addedge(u, v);
addedge(v, u);
}
getcycle(1);
for (int i = 1; i <= cnt; i++) {
for (int j = 1; j <= n; j++) vis[j] = (num[j] != 0);
rt = q[i];
dis[q[i]] = 1;
dfs(q[i]);
}
for (int i = 1; i <= n; i++) {
memset(vis, false, sizeof(vis));
rt = i;
solve(i, 1);
}
ans += n;
printf("%.10lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
double p[3010][3010];
vector<int> v[3010], cycle;
bool vis[3010], oncycle[3010];
int stk[3010], top = 0, dep[3010];
void dfs1(int np, int fath) {
if (!cycle.empty()) return;
vis[np] = 1;
stk[++top] = np;
for (int &x : v[np]) {
if (x == fath) continue;
if (vis[x] && !cycle.size()) {
int p = top;
while (stk[p] != x) {
cycle.push_back(stk[p]);
p--;
}
cycle.push_back(x);
} else
dfs1(x, np);
}
top--;
}
void dfs2(int np, int fath, int st, int dis) {
p[st][np] = 1.0 / dis;
for (int &x : v[np]) {
if (x == fath) continue;
if (oncycle[np] && oncycle[x]) continue;
dfs2(x, np, st, dis + 1);
}
}
vector<int> subt[3010];
void dfs3(int np, int fath, int st) {
dep[np] = dep[fath] + 1;
subt[st].push_back(np);
for (int &x : v[np]) {
if (x == fath) continue;
if (oncycle[np] && oncycle[x]) continue;
dfs3(x, np, st);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, ti, tj; i <= n; i++) {
scanf("%d%d", &ti, &tj);
ti++;
tj++;
v[ti].push_back(tj);
v[tj].push_back(ti);
}
dfs1(1, 0);
for (auto &x : cycle) oncycle[x] = 1;
for (int i = 1; i <= n; i++) dfs2(i, 0, i, 1);
for (auto &x : cycle) dfs3(x, 0, x);
int ps = cycle.size();
for (int i = 0; i < ps; i++) {
for (int j = 0; j < ps; j++) {
if (i != j) {
int l1 = (i > j) ? (i - j - 1) : (j - i - 1);
int l2 = ps - 2 - l1;
for (int &x : subt[cycle[i]]) {
for (int &y : subt[cycle[j]]) {
int l3 = dep[x] + dep[y];
p[x][y] = 1.0 / (l1 + l3) + 1.0 / (l2 + l3) - 1.0 / (l1 + l2 + l3);
}
}
}
}
}
double ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) ans += p[i][j];
printf("%.10lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int entry[3005], low[3005], n, tme = 1, scc[3005], sp[3005], sp2[3005], cycle,
cnt, cc;
vector<int> myvec[3005], ans;
bool bridges[3005][3005];
double prob, ret;
queue<int> q;
int dfs(int x, int p) {
int i, j, k;
low[x] = entry[x] = tme++;
for (i = 0; i < myvec[x].size(); i++) {
j = myvec[x][i];
if (j == p) continue;
if (entry[j] == 0) {
k = dfs(j, x);
if (k > entry[x]) {
bridges[min(j, x)][max(j, x)] = 1;
}
low[x] = min(low[x], k);
} else
low[x] = min(low[x], entry[j]);
}
return low[x];
}
void make_scc(int x, int c) {
scc[x] = c;
cnt++;
int i, j, k;
for (i = 0; i < myvec[x].size(); i++) {
j = myvec[x][i];
if (scc[j] != -1) continue;
if (bridges[min(j, x)][max(j, x)]) continue;
make_scc(j, c);
}
}
int main() {
int i, j, k, p;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scc[i] = -1;
scanf("%d %d", &j, &k);
myvec[j].push_back(k);
myvec[k].push_back(j);
}
dfs(0, -1);
for (i = 0; i < n; i++) {
if (scc[i] != -1) continue;
cnt = 0;
make_scc(i, i);
if (cnt > 1) {
cc = i;
cycle = cnt;
}
}
for (ret = 0, i = 0; i < n; i++) {
for (j = 0; j < n; j++) sp[j] = -1;
q.push(i);
sp[i] = sp2[i] = 0;
while (!q.empty()) {
k = q.front();
q.pop();
for (j = 0; j < myvec[k].size(); j++) {
p = myvec[k][j];
if (sp[p] != -1) continue;
sp[p] = sp[k] + (bridges[min(k, p)][max(k, p)]);
sp2[p] = sp2[k] + (!bridges[min(k, p)][max(k, p)]);
q.push(p);
}
}
for (j = 0; j < n; j++) {
if (sp2[j] == 0) {
ret += (1 / (double)(sp[j] + 1));
} else if (sp[j] == 0) {
double d = sp2[j] + 1.0;
double d2 = cycle - d + 2;
ret += (1 / d) + (1 / d2) - (1 / (d + d2 - 2));
} else {
double d = sp[j] + 2.0;
double d2 = sp2[j] - 1.0;
double d3 = cycle - d2 - 2;
ret += (1 / (d + d2)) + (1 / (d + d3)) - (1 / (d + d2 + d3));
}
}
}
printf("%.8lf\n", ret);
return 0;
}
|
#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);
}
|
#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);
}
|
#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);
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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(); }
|
#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);
}
|
#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;
}
|
#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);
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
#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);
}
|
#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;
}
|
#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;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.