#include <bits/stdc++.h>
#define int long long
#define Node pair<int, pair<int,int>>
using namespace std;

int const N = 4e3 + 5;
int const INF = 1e18;

vector <pair<int,double>> g[N]; // вершина - длина
vector <pair<int, double>> graph[N]; // перестроенный входной граф
int len[N][N];
int start;
int n;

void dfs(int u, int sum, int p = -1) {
      len[start][u] = sum;
      for (auto i : g[u]) {
            if (i.first != p) {
                  dfs(i.first, sum + i.second, u);
            }
      }
}

int reu(int i) {
      if (i > n) return (i - n);
      else return (i);
}

pair <double, vector<int>> dij(double x) {
      vector <double> d(2 * n + 1, INF); d[x] = 0;
      vector <int>  way(2 * n + 1, -1);
      set <pair<double, int>> que;
      que.insert(make_pair(0, x));
      while (que.size()) {
            auto top = *que.begin();
            int from = top.second;
            int len = top.first;
            que.erase(top);
            if (d[from] != top.first) continue;

            for (auto v : graph[from]) {
                  if (d[v.first] > d[from] + v.second) {
                        d[v.first] = d[from] + v.second;
                        way[v.first] = from;
                        que.insert(make_pair(d[v.first], v.first));
                  }
            }
      }

      vector <int> result;

      for (int i = n + 1; i != 1; i = way[i]) {
            if (i == -1) break;
            if (result.size() == 0 || reu(i) != reu(result.back())) result.push_back(reu(i));
            if (i == -1) break;
      }

      return make_pair(d[n + 1], result);
}

signed main() {
      cin >> n;

      vector <pair<double,double>> v; // first - подгтовка, second - скорость
      v.push_back(make_pair(INF, INF));

      for (int i = 1; i <= n; ++i) {
            int a, b;
            cin >> a >> b;
            v.push_back(make_pair(a, b));
      }

      for (int i = 0; i < n - 1; ++i) {
            double a, b, len;
            cin >> a >> b >> len;
            g[(int)a].push_back(make_pair(b, len));
            g[(int)b].push_back(make_pair(a, len));
      }

      for (int i = 1; i <= n; ++i) {
            start = i;
            dfs(i, 0);
      }

      for (int i = 1; i <= n; ++i) {
            graph[n + i].push_back(make_pair(i, v[i].first));
      }


      for (int i = 1; i <= n; ++i) {
            for (int j = n + 1; j <= 2 * n; ++j) {
                  if (j != n + i) {
                        graph[i].push_back(make_pair(j, len[i][j - n] / v[i].second));
                  }
            }
      }

      double ans = -INF;
      vector <int> out;

      for (int i = n + 1; i <= 2 * n; ++i) {
            auto res = dij(i);
            if (res.first > ans) {
                  ans = res.first;
                  out = res.second;
            }
      }

      cout <<fixed << setprecision(10) << ans << '\n';
      reverse(out.begin(), out.end());

      for (int i = 0; i < out.size(); ++i) {
            cout << out[i];
            if (i != out.size() - 1) cout << ' ';
      }

      cout << '\n';

      return 0;
}