#include <bits/stdc++.h>
using namespace std;
struct state {
  int sz;
  long long sumOfEdges, rev;
} B[100050];
vector<vector<int> > tree;
vector<vector<long long> > pre, suff;
int n, m, depth[100050], M[100050][25];
void dfs(int node, int d) {
  int sz = 1, er = -1;
  long long sumOfEdges = 0;
  depth[node] = d;
  for (int i = 0; i < (int)tree[node].size(); ++i) {
    int to = tree[node][i];
    if (!depth[to]) {
      dfs(to, d + 1);
      sz += B[to].sz;
      sumOfEdges += B[to].sz + B[to].sumOfEdges;
    } else
      er = i;
  }
  if (er != -1) {
    M[node][0] = tree[node][er];
    tree[node].erase(tree[node].begin() + er);
  }
  B[node].sz = sz;
  B[node].sumOfEdges = sumOfEdges;
  int k = tree[node].size();
  long long a = 0, b = 0;
  pre[node].resize(k);
  suff[node].resize(k);
  for (int i = 0; i < k; ++i) {
    pre[node][i] = a;
    suff[node][k - i - 1] = b;
    a += B[tree[node][i]].sumOfEdges + B[tree[node][i]].sz;
    b += B[tree[node][k - i - 1]].sumOfEdges + B[tree[node][k - i - 1]].sz;
  }
  return;
}
void dfs2(int node, long long sum) {
  B[node].rev = sum + n - B[node].sz;
  for (int i = 0; i < (int)tree[node].size(); ++i)
    dfs2(tree[node][i], pre[node][i] + suff[node][i] + B[node].rev);
  return;
}
inline double process(int u, int v) {
  if (depth[u] > depth[v]) swap(u, v);
  int U = u, V = v;
  int d1 = 0, d2 = 0;
  for (int i = 20; i > -1; --i)
    while (depth[v] - (1 << i) > depth[u]) {
      v = M[v][i];
      d1 += (1 << i);
    }
  if (M[v][0] == u) {
    d1 += 2;
    for (int i = 0; i < (int)tree[u].size(); ++i) {
      int to = tree[u][i];
      if (to == v) {
        long long k = B[U].rev + pre[U][i] + suff[U][i];
        cerr << v << "   ";
        if (U == 0) k = B[0].sumOfEdges - B[v].sumOfEdges - B[v].sz;
        cerr << k << "  \n";
        long long num = 1LL * d1 * (n - B[v].sz) + k;
        num = num * B[V].sz + B[V].sumOfEdges * (n - B[to].sz);
        return 1.0 * num / (1.0 * (n - B[to].sz) * B[V].sz);
      }
    }
    assert(false);
  }
  if (depth[v] > depth[u]) {
    v = M[v][0];
    ++d1;
  }
  assert(depth[u] == depth[v]);
  for (int i = 20; i > -1; --i)
    if (M[u][i] != M[v][i]) {
      u = M[u][i];
      v = M[v][i];
      d2 += (1 << i);
    }
  u = M[u][0];
  v = M[v][0];
  ++d2;
  assert(u == v);
  d1 += (d2 << 1) + 1;
  long long num = 1LL * d1 * B[U].sz + B[U].sumOfEdges;
  num = num * B[V].sz + B[V].sumOfEdges * B[U].sz;
  return (1.0 * num / (1.0 * B[U].sz * B[V].sz));
}
int main() {
  scanf("%d%d", &n, &m);
  tree.resize(n + 5);
  pre.resize(n + 5);
  suff.resize(n + 5);
  memset(M, 0xff, sizeof(M));
  for (int i = 1; i < n; ++i) {
    int a, b;
    scanf("%d%d", &a, &b);
    --a;
    --b;
    tree[a].push_back(b);
    tree[b].push_back(a);
  }
  dfs(0, 1);
  dfs2(0, 0);
  for (int j = 1; j < 21; ++j)
    for (int i = 0; i < n; ++i)
      if (M[i][j - 1] != -1) M[i][j] = M[M[i][j - 1]][j - 1];
  while (m--) {
    int a, b;
    scanf("%d%d", &a, &b);
    --a;
    --b;
    printf("%.15lf\n", process(a, b));
  }
  return 0;
}
