#include <bits/stdc++.h>
using namespace std;
int INT_MAX_VAL = (int)0x3F3F3F3F;
int INT_MIN_VAL = (int)-0x3F3F3F3F;
long long LONG_MAX_VAL = (long long)0x3F3F3F3F3F3F3F3F;
long long LONG_MIN_VAL = (long long)-0x3F3F3F3F3F3F3F3F;
struct Node {
  int in_time;
  int out_time;
  int sub_tree_size;
  long long sub_tree_len_sum;
  int parent_tree_size;
  long long parent_tree_len_sum;
  int level;
  int lca[20];
};
Node nodes[500006];
vector<int> graph[500006];
void dfs(int v, int p, int level, int& time) {
  nodes[v].in_time = time++;
  nodes[v].lca[0] = p;
  for (int i = 1; i < 20; ++i) {
    nodes[v].lca[i] = nodes[nodes[v].lca[i - 1]].lca[i - 1];
  }
  for (auto w : graph[v]) {
    if (w == p) continue;
    dfs(w, v, level + 1, time);
    nodes[v].sub_tree_size += nodes[w].sub_tree_size;
    nodes[v].sub_tree_len_sum +=
        nodes[w].sub_tree_len_sum + nodes[w].sub_tree_size;
  }
  nodes[v].sub_tree_size += 1;
  nodes[v].level = level;
  nodes[v].out_time = time++;
}
void dfs2(int v, int p) {
  for (auto w : graph[v]) {
    if (w == p) continue;
    nodes[w].parent_tree_size = nodes[v].parent_tree_size +
                                nodes[v].sub_tree_size - nodes[w].sub_tree_size;
    nodes[w].parent_tree_len_sum =
        nodes[v].parent_tree_len_sum + nodes[w].parent_tree_size +
        nodes[v].sub_tree_len_sum - nodes[w].sub_tree_len_sum -
        nodes[w].sub_tree_size;
    dfs2(w, v);
  }
}
int NodeDistance(int v, int u) {
  int result = 0;
  if (nodes[v].level < nodes[u].level) {
    swap(u, v);
  }
  for (int i = 20 - 1; i >= 0; --i) {
    if (nodes[v].level - (1 << i) >= nodes[u].level) {
      result += 1 << i;
      v = nodes[v].lca[i];
    }
  }
  if (u == v) return result;
  for (int i = 20 - 1; i >= 0; --i) {
    if (nodes[v].lca[i] != nodes[u].lca[i]) {
      v = nodes[v].lca[i];
      u = nodes[u].lca[i];
      result += 2 * (1 << i);
    }
  }
  if (u != v) result += 2;
  return result;
}
int FindChild(int u, int v) {
  for (int i = 20 - 1; i >= 0; --i) {
    if ((nodes[v].level - (1 << i)) > nodes[u].level) {
      v = nodes[v].lca[i];
    }
  }
  return v;
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int n, m;
  cin >> n >> m;
  for (int i = 0; i + 1 < n; ++i) {
    int a, b;
    cin >> a >> b;
    graph[a].push_back(b);
    graph[b].push_back(a);
  }
  vector<pair<int, int> > pairs;
  for (int i = 0; i < m; ++i) {
    int u, v;
    cin >> u >> v;
    pairs.emplace_back(u, v);
  }
  int time = 0;
  dfs(1, 1, 0, time);
  dfs2(1, 0);
  for (auto p : pairs) {
    int u = p.first;
    int v = p.second;
    long long dist = NodeDistance(v, u);
    if (nodes[u].in_time > nodes[v].in_time) {
      swap(u, v);
    }
    long long u_tree_size = nodes[u].sub_tree_size;
    long long u_len_sum = nodes[u].sub_tree_len_sum;
    long long v_tree_size = nodes[v].sub_tree_size;
    long long v_len_sum = nodes[v].sub_tree_len_sum;
    if (nodes[u].out_time > nodes[v].in_time) {
      int p = FindChild(u, v);
      u_tree_size -= nodes[p].sub_tree_size;
      u_len_sum -= nodes[p].sub_tree_size + nodes[p].sub_tree_len_sum;
      u_tree_size += nodes[u].parent_tree_size;
      u_len_sum += nodes[u].parent_tree_len_sum;
    }
    long long result = 0;
    result += u_tree_size * v_tree_size * (dist + 1);
    result += u_tree_size * v_len_sum;
    result += u_len_sum * v_tree_size;
    long long num_ways = u_tree_size * v_tree_size;
    cout << setprecision(8) << fixed << double(result) / num_ways << '\n';
  }
  return 0;
}
