#include <bits/stdc++.h>
using namespace std;
const int MAXLOG = 18;
int timer = 0;
typedef struct {
  int p, d, tin, tout;
  long long dp_e, dp, s, udp_e, udp, us;
  vector<int> ch;
  int bins[MAXLOG];
} TVertex;
vector<TVertex> tree;
vector<vector<int> > g;
void make_tree(int v, int p, int cd) {
  tree[v].d = cd;
  tree[v].p = p;
  tree[v].bins[0] = p;
  tree[v].tin = timer++;
  tree[v].dp = 0;
  tree[v].dp_e = 1ll;
  tree[v].s = 1ll;
  for (int i = 0; i < (int)g[v].size(); ++i) {
    int to = g[v][i];
    if (to == p) continue;
    make_tree(to, v, cd + 1);
    tree[v].dp_e += tree[to].dp_e;
    tree[v].s += tree[to].s;
    tree[v].ch.push_back(to);
  }
  tree[v].tout = timer++;
}
void calc_up(int v, long long udp_e, long long udp, long long us) {
  long long sum_dp_e = udp_e, sum_dp = udp + udp_e, sum_s = us;
  for (int i = 0; i < (int)tree[v].ch.size(); ++i) {
    int to = tree[v].ch[i];
    sum_dp_e += tree[to].dp_e;
    sum_dp += tree[to].dp + tree[to].dp_e;
    sum_s += tree[to].s;
  }
  for (int i = 0; i < (int)tree[v].ch.size(); ++i) {
    int to = tree[v].ch[i];
    tree[to].udp_e = sum_dp_e - tree[to].dp_e + 1;
    tree[to].udp = sum_dp - tree[to].dp - tree[to].dp_e;
    tree[to].us = sum_s - tree[to].s + 1;
    calc_up(to, tree[to].udp_e, tree[to].udp, tree[to].us);
  }
}
bool par(int a, int b) {
  return (tree[a].tin < tree[b].tin) && (tree[a].tout > tree[b].tout);
}
int get_lca(int a, int b) {
  if (par(a, b)) return a;
  if (par(b, a)) return b;
  for (int i = MAXLOG - 1; i >= 0; --i) {
    if (!par(tree[a].bins[i], b)) {
      a = tree[a].bins[i];
    }
  }
  return tree[a].p;
}
int get_dist(int a, int b) {
  int lca = get_lca(a, b);
  return tree[a].d + tree[b].d - 2 * tree[lca].d;
}
int get_nc(int a, int b) {
  int dist = get_dist(a, b);
  dist -= 1;
  for (int i = MAXLOG - 1; i >= 0; --i) {
    if (dist - (1 << i) >= 0) {
      dist -= (1 << i);
      b = tree[b].bins[i];
    }
  }
  return b;
}
void calc_dp(int v) {
  tree[v].dp = 0;
  for (int i = 0; i < (int)tree[v].ch.size(); ++i) {
    int to = tree[v].ch[i];
    calc_dp(to);
    tree[v].dp += tree[to].dp + tree[to].dp_e;
  }
}
int main() {
  int n, m;
  cin >> n >> m;
  g.resize(n);
  tree.resize(n);
  for (int i = 0; i < n - 1; ++i) {
    int a, b;
    cin >> a >> b;
    --a, --b;
    g[a].push_back(b), g[b].push_back(a);
  }
  make_tree(0, 0, 0);
  for (int i = 1; i < MAXLOG; ++i) {
    for (int j = 0; j < n; ++j) {
      tree[j].bins[i] = tree[tree[j].bins[i - 1]].bins[i - 1];
    }
  }
  calc_dp(0);
  calc_up(0, 0, 0, 0);
  for (int i = 0; i < m; ++i) {
    int a, b;
    cin >> a >> b;
    --a, --b;
    if (par(b, a)) swap(a, b);
    if (par(a, b)) {
      long long ans =
          (tree[b].dp) * (tree[a].s - tree[get_nc(a, b)].s + tree[a].us) +
          tree[b].s * (tree[a].dp + tree[a].udp + tree[a].udp_e -
                       tree[get_nc(a, b)].dp - tree[get_nc(a, b)].dp_e) +
          ((long long)get_dist(a, b)) * tree[b].s *
              (tree[a].s - tree[get_nc(a, b)].s + tree[a].us);
      double dans = ans;
      double dn = tree[b].s * (tree[a].s - tree[get_nc(a, b)].s + tree[a].us);
      dans = dans / dn;
      printf("%.13lf\n", dans + 1.0);
    } else {
      long long ans = (tree[a].dp) * (tree[b].s) + (tree[b].dp * tree[a].s) +
                      ((long long)get_dist(a, b)) * tree[a].s * tree[b].s;
      double dans = ans;
      double dn = tree[a].s * tree[b].s;
      dans = dans / dn;
      printf("%.13lf\n", dans + 1.0);
    }
  }
  return 0;
}
