Problem:
問題 5:　タクシー (Taxis)

問題

IOI 国は町 1 から町 N までの N 個の町からなり，町と町とは道路で結ばれている．IOI 国には K 本の道路があり，すべての道路は異なる 2 つの町を結んでいる．車は道路を双方向に自由に移動できるが，道路以外を通ってある町から別の町に行くことはできない．

IOI 国の町 1 に住む JOI 君は，町 N に住む祖母の家までタクシーで行くことにした．IOI 国にはタクシー会社 1 からタクシー会社 N までの N 個のタクシー会社がある．IOI 国のタクシー会社には次のような少々特殊な規則がある．

タクシー会社 i のタクシーには，町 i でのみ乗車できる．

タクシー会社 i のタクシーの運賃は，利用した距離によらず Ci である．

タクシー会社 i のタクシーは，乗車してから連続して最大 Ri 本の道路しか通ることができない．

たとえば R1 = 2 の場合，町 1 からタクシー会社 1 のタクシーに乗車すると，最大 2 本の道路しか通ることができないため，道路を 3 本以上通るためには途中の町でタクシーを乗り換える必要がある．

JOI 君は町以外の地点でタクシーに乗ったりタクシーから降りたりすることはできない．また，タクシー以外の移動手段を用いることもできない．JOI 君が町 N に到達するために必要な運賃の合計の最小値を求めるプログラムを作成せよ．

入力

入力は 1 + N + K 行からなる．

1 行目には，2 つの整数 N, K (2 ≤ N ≤ 5000, N - 1 ≤ K ≤ 10000) が空白を区切りとして書かれている．これは，IOI 国が N 個の町からなることと，IOI 国の道路の本数が K 本であることを表す．

続く N 行のうちの i 行目 (1 ≤ i ≤ N) には，2 つの整数 Ci, Ri (1 ≤ Ci ≤ 10000, 1 ≤ Ri ≤ N) が空白を区切りとして書かれている．これは，タクシー会社 i のタクシーの運賃が Ci で，乗車してから連続して最大 Ri 本の道路しか通ることができないことを表す．

続く K 行のうちの j 行目 (1 ≤ j ≤ K) には，異なる 2 つの整数 Aj, Bj (1 ≤ Aj ＜ Bj ≤ N) が空白を区切りとして書かれている．これは，町 Aj と町 Bj との間に道路が存在することを表す．同じ (Aj, Bj) の組が 2 回以上書かれていることはない．

与えられる入力データにおいては，どの町から別のどの町へもタクシーを乗り継いで行くことができることが保証されている．

出力

JOI 君が町 1 から町 N まで行くのに必要な運賃の合計の最小値を表す整数を 1 行で出力せよ．

入出力例

入力例

6 6
400 2
200 1
600 3
1000 1
300 5
700 4
1 2
2 3
3 6
4 6
1 5
2 4

出力例

700

上の入出力例は，以下の図に対応している．円は町を，線は道路を表す．

この入出力例でJOI 君が最小の運賃で町 6 に到達するには，以下のようにする．

町 1 からタクシーに乗って町 5 に行く． (運賃 400)

町 5 からタクシーに乗って町 6 に行く． (運賃 300)

JOI 君がこのようなルートを通った場合の運賃の合計は 400 + 300 = 700 であるので，700 を出力する．

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in C++11 (judge verdict: Time Limit Exceeded)

#include<bits/stdc++.h>
using namespace std;

typedef vector<vector<int>> Graph;

set<int> bfs(const Graph& G, int start, int r) {
  set<int> res;
  struct Node {int vertex, distance;};
  queue<Node> q;
  q.push({start, 0});
  while(!q.empty()) {
    auto node = q.front();
    q.pop();
    if(r < node.distance) break;
    if(res.count(node.vertex)) continue;
    res.insert(node.vertex);
    for(const auto& v: G[node.vertex]) if(!res.count(v)) q.push({v, node.distance + 1});
  }
  return res;
}

int Dijkstra(const Graph& G, const vector<int>& C) {
  const int INF = INT_MAX >> 1;
  int N = G.size();
  struct Node {int vertex, cost, depth;};
  priority_queue<Node, vector<Node>, function<bool(Node, Node)>> q([](Node lhs, Node rhs){
    if(lhs.cost != rhs.cost) return lhs.cost > rhs.cost;
    return lhs.vertex > rhs.vertex;
  });
  vector<int> distance(N, INF);
  q.push({0, 0, 0});
  while(!q.empty()) {
    auto node = q.top();
    q.pop();
    if(node.vertex == N - 1) return node.cost;
    if(N/2 <= node.depth) break;
    if(distance[node.vertex] != INF) continue;
    distance[node.vertex] = node.cost;
    for(const auto& v: G[node.vertex]) if(distance[v] == INF) q.push({v, node.cost + C[node.vertex], node.depth + 1});
  }
  // ?????´??¢?´¢
  Graph R(N);
  for(int u = 0; u < N; ++u) for(const auto& v: G[u]) R[v].push_back(u);
  vector<int> rdistance(N, INF);
  q = {};
    q.push({(int)N-1, 0, 0});
  while(!q.empty()) {
    auto node = q.top();
    q.pop();
    if(node.vertex == 0) return node.cost;
    if(N/2 <= node.depth) break;
    if(rdistance[node.vertex] != INF) continue;
    rdistance[node.vertex] = node.cost;
    for(const auto& v: R[node.vertex]) if(rdistance[v] == INF) q.push({v, node.cost + C[v], node.depth + 1});
  }
  int res = INF;
  for(int i = 0; i < N; ++i) {
    res = min(res, distance[i] + rdistance[i]);
  }
  return res;
}

int main() {
  int N, K;
  cin >> N >> K;

  vector<int> C(N), R(N);
  for(int i = 0; i < N; ++i) cin >> C[i] >> R[i];

  Graph G(N);
  for(int i = 0; i < K; ++i) {
    int A, B;
    cin >> A >> B;
    --A;
    --B;
    G[A].push_back(B);
    G[B].push_back(A);
  }

  Graph H(N);
  for(int u = 0; u < N; ++u) for(const auto& v: bfs(G, u, R[u])) H[u].push_back(v);
  cout << Dijkstra(H, C) << endl;
}