#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int lg = 25;
int dep[MAXN];
int fat[MAXN][36];
int son[MAXN];
long long ssum[MAXN];
long long asum[MAXN];
int head[MAXN];
int nedge;
int n, m;
struct edge {
  int u, v, nxt;
} edges[MAXN * 2];
void add_edge(int u, int v) {
  edges[nedge].u = u;
  edges[nedge].v = v;
  edges[nedge].nxt = head[u];
  head[u] = nedge++;
}
void dfs(int u, int fa, int dp) {
  fat[u][0] = fa;
  dep[u] = dp;
  son[u] = 1;
  ssum[u] = 0;
  for (int i = head[u]; i != -1; i = edges[i].nxt) {
    int v = edges[i].v;
    if (v == fa) continue;
    dfs(v, u, dp + 1);
    son[u] += son[v];
    ssum[u] += ssum[v] + son[v];
  }
}
void dfs2(int u, int fa) {
  for (int i = head[u]; i != -1; i = edges[i].nxt) {
    int v = edges[i].v;
    if (v == fa) continue;
    asum[v] = asum[u] - son[v] + (n - son[v]);
    dfs2(v, u);
  }
}
int jump(int u, int delta) {
  for (int i = lg; i >= 0; i--) {
    if (delta & (1 << i)) {
      u = fat[u][i];
    }
  }
  return u;
}
void binary_lifting() {
  memset(fat, -1, sizeof fat);
  dfs(1, 0, 0);
  for (int j = 1; (1 << j) <= n; j++) {
    for (int i = 1; i <= n; i++) {
      if (fat[i][j - 1] != -1) {
        fat[i][j] = fat[fat[i][j - 1]][j - 1];
      }
    }
  }
}
int lca(int a, int b) {
  if (dep[a] < dep[b]) swap(a, b);
  a = jump(a, dep[a] - dep[b]);
  if (a == b) return a;
  for (int i = lg; i >= 0; i--) {
    if (fat[a][i] != -1 && fat[a][i] != fat[b][i]) {
      a = fat[a][i];
      b = fat[b][i];
    }
  }
  return fat[a][0];
}
int main() {
  int u, v;
  memset(head, -1, sizeof head);
  nedge = 0;
  scanf("%d %d", &n, &m);
  for (int i = 1; i <= n - 1; i++) {
    scanf("%d %d", &u, &v);
    add_edge(u, v);
    add_edge(v, u);
  }
  binary_lifting();
  asum[1] = ssum[1];
  dfs2(1, 0);
  for (int i = 1; i <= m; i++) {
    scanf("%d %d", &u, &v);
    int tmp = lca(u, v);
    double sum = dep[u] + dep[v] - 2 * dep[tmp];
    if (dep[u] > dep[v]) swap(u, v);
    int nxt = jump(v, dep[v] - dep[u] - 1);
    if (u == tmp) {
      sum *= son[v];
      sum *= (n - son[nxt]);
      sum += ssum[v] * (n - son[nxt]);
      sum += (asum[u] - ssum[nxt] - son[nxt]) * son[v];
      printf("%.8f\n", 1.0 + sum / son[v] / (n - son[nxt]));
    } else {
      sum *= son[v];
      sum *= son[u];
      sum += ssum[v] * son[u];
      sum += ssum[u] * son[v];
      printf("%.8f\n", 1.0 + sum / son[v] / son[u]);
    }
  }
  return 0;
}
