#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
struct Edge {
  int v, next;
} e[MAXN * 2];
int head[MAXN], NE;
int fat[MAXN][20];
int size[MAXN], depth[MAXN];
long long int dp[MAXN], udp[MAXN];
void init() {
  NE = 0;
  memset(head, -1, sizeof(head));
}
void add_edge(int u, int v) {
  e[NE].v = v, e[NE].next = head[u];
  head[u] = NE++;
}
int n, m;
void dfs1(int u, int fa) {
  fat[u][0] = fa;
  size[u] = 1;
  depth[u] = depth[fa] + 1;
  for (int i = head[u]; i != -1; i = e[i].next) {
    int v = e[i].v;
    if (v == fa) continue;
    dfs1(v, u);
    size[u] += size[v];
  }
  return;
}
void dfs(int u, int fa) {
  dp[u] = 0;
  for (int i = head[u]; i != -1; i = e[i].next) {
    int v = e[i].v;
    if (v == fa) continue;
    dfs(v, u);
    dp[u] += dp[v];
    dp[u] += size[v];
  }
}
void udfs(int u, int fa) {
  long long int tmp = 0;
  tmp += udp[u];
  tmp += size[1] - size[u];
  for (int i = head[u]; i != -1; i = e[i].next) {
    int v = e[i].v;
    if (v == fa) continue;
    tmp += dp[v];
    tmp += size[v];
  }
  for (int i = head[u]; i != -1; i = e[i].next) {
    int v = e[i].v;
    if (v == fa) continue;
    udp[v] = tmp - dp[v] - size[v];
    udfs(v, u);
  }
  return;
}
int LCA(int x, int y) {
  for (int i = 18; i >= 0; i--) {
    if (depth[fat[x][i]] >= depth[y]) {
      x = fat[x][i];
    }
  }
  if (x == y) return x;
  for (int i = 18; i >= 0; i--) {
    if (fat[x][i] != fat[y][i]) {
      x = fat[x][i];
      y = fat[y][i];
    }
  }
  return fat[x][0];
}
int main() {
  while (scanf("%d%d", &n, &m) != EOF) {
    int ta, tb;
    init();
    for (int i = 1; i < n; i++) {
      scanf("%d%d", &ta, &tb);
      add_edge(ta, tb);
      add_edge(tb, ta);
    }
    depth[1] = 0;
    dfs1(1, 1);
    for (int i = 1; i <= 18; i++) {
      for (int j = 1; j <= n; j++) {
        fat[j][i] = fat[fat[j][i - 1]][i - 1];
      }
    }
    dfs(1, 1);
    udp[1] = 0;
    udfs(1, 1);
    int u, v;
    for (int i = 0; i < m; i++) {
      scanf("%d%d", &u, &v);
      if (depth[u] < depth[v]) swap(u, v);
      int lca = LCA(u, v);
      long long int tmp = depth[u] + depth[v] - 2 * depth[lca];
      long long int ans = 0;
      if (lca != v) {
        ans = (long long int)size[u] * size[v] * tmp +
              (long long int)dp[u] * size[v] + (long long int)dp[v] * size[u];
        printf("%f\n", ans * 1.0 / (long long int)(size[v] * size[u]) + 1.0);
      } else {
        int low = u;
        for (int i = 18; i >= 0; i--) {
          if (depth[fat[low][i]] > depth[v]) {
            low = fat[low][i];
          }
        }
        ans += (long long int)(size[1] - size[low]) * dp[u] +
               (long long int)size[u] * udp[low];
        ans += (long long int)(size[1] - size[low]) * size[u] * tmp;
        printf(
            "%f\n",
            ans * 1.0 / ((long long int)(size[1] - size[low]) * size[u]) + 1.0);
      }
    }
  }
  return 0;
}
