#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
const int MAXL = 18;
int N, M;
vector<int> adj[MAXN];
int a[MAXN], b[MAXN];
int up_edge[MAXN];
int dep[MAXN];
int par[MAXN][MAXL];
bool comp[MAXN][2];
int size[MAXN][2];
long long total[MAXN][2];
void precomp(int loc, int abv) {
  par[loc][0] = abv;
  for (int i = 1; i < MAXL; i++) par[loc][i] = par[par[loc][i - 1]][i - 1];
  for (int e : adj[loc]) {
    int nbr = a[e] + b[e] - loc;
    if (nbr == abv) continue;
    dep[nbr] = dep[loc] + 1;
    up_edge[nbr] = e;
    precomp(nbr, loc);
  }
}
int go_up(int loc, int far) {
  for (int i = 0; i < MAXL; i++)
    if ((far >> i) & 1) loc = par[loc][i];
  return loc;
}
int lca(int a, int b) {
  if (dep[a] > dep[b]) swap(a, b);
  b = go_up(b, dep[b] - dep[a]);
  if (a == b) return a;
  for (int i = MAXL - 1; i >= 0; i--) {
    if (par[a][i] != par[b][i]) {
      a = par[a][i];
      b = par[b][i];
    }
  }
  return par[a][0];
}
int dist(int a, int b) { return dep[a] + dep[b] - 2 * dep[lca(a, b)]; }
double solve(int edge, int dir) {
  if (comp[edge][dir]) {
    return total[edge][dir] / double(size[edge][dir]);
  }
  comp[edge][dir] = true;
  int loc = dir ? a[edge] : b[edge];
  size[edge][dir] = 1;
  for (int e : adj[loc]) {
    if (e == edge) continue;
    int ndir = (a[e] == loc) ? 0 : 1;
    solve(e, ndir);
    size[edge][dir] += size[e][ndir];
    total[edge][dir] += size[e][ndir] + total[e][ndir];
  }
  return total[edge][dir] / double(size[edge][dir]);
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0), cout.tie(0), cout.precision(15);
  cin >> N >> M;
  for (int i = 0; i < N - 1; i++) {
    cin >> a[i] >> b[i];
    a[i]--, b[i]--;
    adj[a[i]].push_back(i);
    adj[b[i]].push_back(i);
  }
  up_edge[0] = -1;
  precomp(0, 0);
  for (int i = 0; i < N - 1; i++) {
    if (dep[a[i]] > dep[b[i]]) swap(a[i], b[i]);
  }
  int u, v;
  for (int i = 0; i < M; i++) {
    cin >> u >> v;
    u--, v--;
    if (dep[u] > dep[v]) swap(u, v);
    int p = lca(u, v);
    if (p == u) {
      int blw = go_up(v, dep[v] - dep[u] - 1);
      cout << 1 + dist(u, v) + solve(up_edge[blw], 1) + solve(up_edge[v], 0)
           << "\n";
    } else {
      cout << 1 + dist(u, v) + solve(up_edge[u], 0) + solve(up_edge[v], 0)
           << "\n";
    }
  }
}
