#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool chmin(T1 &a, T2 b) {
  return b < a && (a = b, true);
}
template <class T1, class T2>
bool chmax(T1 &a, T2 b) {
  return a < b && (a = b, true);
}
struct LCA {
  vector<vector<int>> g, parent;
  vector<int> depth;
  LCA(int n) : g(n), parent(24, vector<int>(n)), depth(n) {}
  void add(int u, int v) {
    g[u].push_back(v);
    g[v].push_back(u);
  }
  void build(int root = 0) {
    dfs(root, -1);
    for (int i = 0; i < 23; i++)
      for (int j = 0; j < g.size(); j++)
        parent[i + 1][j] = parent[i][j] == -1 ? -1 : parent[i][parent[i][j]];
  }
  void dfs(int curr, int prev) {
    parent[0][curr] = prev;
    for (int next : g[curr])
      if (next != prev) depth[next] = depth[curr] + 1, dfs(next, curr);
  }
  int ancestor(int v, int k) {
    for (int j = 0; k > 0; k >>= 1, j++)
      if (k & 1) v = parent[j][v];
    return v;
  }
  int query(int u, int v) {
    u = ancestor(u, depth[u] - depth[v]);
    v = ancestor(v, depth[v] - depth[u]);
    if (u == v) return u;
    for (int i = 23; i >= 0; i--)
      if (parent[i][u] != parent[i][v]) u = parent[i][u], v = parent[i][v];
    return parent[0][u];
  }
};
int n, m;
vector<int> g[101010];
long double distSub[101010];
long double distAll[101010];
long long sub[101010];
void dfs(int curr, int prev) {
  sub[curr] = 1;
  for (int next : g[curr])
    if (next != prev) {
      dfs(next, curr);
      sub[curr] += sub[next];
      distSub[curr] += distSub[next] + sub[next];
    }
}
void dfs2(int curr, int prev) {
  distAll[curr] = distSub[curr];
  if (prev != -1) {
    distAll[curr] +=
        distAll[prev] - distSub[curr] - sub[curr] + (n - sub[curr]);
  }
  for (int next : g[curr])
    if (next != prev) dfs2(next, curr);
}
int main() {
  cin >> n >> m;
  LCA lca(n);
  for (int i = 0; i < (n - 1); i++) {
    int u, v;
    scanf("%d %d", &u, &v);
    u--;
    v--;
    g[u].push_back(v);
    g[v].push_back(u);
    lca.add(u, v);
  }
  lca.build();
  vector<int> a(m), b(m);
  for (int i = 0; i < (m); i++) scanf("%d %d", &a[i], &b[i]), a[i]--, b[i]--;
  dfs(0, -1);
  dfs2(0, -1);
  for (int i = 0; i < (m); i++) {
    int l = lca.query(a[i], b[i]);
    int d = lca.depth[a[i]] + lca.depth[b[i]] - 2 * lca.depth[l];
    if (l == b[i]) swap(a[i], b[i]);
    long double ans;
    if (a[i] == l) {
      int x = lca.ancestor(b[i], lca.depth[b[i]] - lca.depth[a[i]] - 1);
      long double subU = n - sub[x];
      long double subL = sub[b[i]];
      long double distU = distAll[a[i]] - (distSub[x] + sub[x]);
      long double distL = distSub[b[i]];
      long double way = subU * subL;
      ans = subU * distL + subL * distU + way * d + way;
      ans /= way;
    } else {
      long double way = sub[a[i]] * sub[b[i]];
      ans =
          sub[b[i]] * distSub[a[i]] + sub[a[i]] * distSub[b[i]] + way * d + way;
      ans /= way;
    }
    printf("%.20f\n", (double)ans);
  }
  return 0;
}
