Problem:
問題 5:　タクシー (Taxis)
問題
IOI 国は町 1 から町 N までの N 個の町からなり，町と町とは道路で結ばれている．IOI 国には K 本の道路があり，すべての道路は異なる 2 つの町を結んでいる．車は道路を双方向に自由に移動できるが，道路以外を通ってある町から別の町に行くことはできない．
IOI 国の町 1 に住む JOI 君は，町 N に住む祖母の家までタクシーで行くことにした．IOI 国にはタクシー会社 1 からタクシー会社 N までの N 個のタクシー会社がある．IOI 国のタクシー会社には次のような少々特殊な規則がある．
タクシー会社 i のタクシーには，町 i でのみ乗車できる．
タクシー会社 i のタクシーの運賃は，利用した距離によらず C
i
である．
タクシー会社 i のタクシーは，乗車してから連続して最大 R
i
本の道路しか通ることができない．
たとえば R
1
= 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 つの整数 C
i
, R
i
(1 ≤ C
i
≤ 10000, 1 ≤ R
i
≤ N) が空白を区切りとして書かれている．これは，タクシー会社 i のタクシーの運賃が C
i
で，乗車してから連続して最大 R
i
本の道路しか通ることができないことを表す．
続く K 行のうちの j 行目 (1 ≤ j ≤ K) には，異なる 2 つの整数 A
j
, B
j
(1 ≤ A
j
＜ B
j
≤ N) が空白を区切りとして書かれている．これは，町 A
j
と町 B
j
との間に道路が存在することを表す．同じ (A
j
, B
j
) の組が 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 を出力する．
問題文と自動審判に使われるデータは、
情報オリンピック日本委員会
が作成し公開している問題文と採点用テストデータです。

Submitted solutions:

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

using VS = vector<string>;    using LL = int;
using VI = vector<int>;       using VVI = vector<VI>;
using PII = pair<int, int>;   using PLL = pair<LL, LL>;
using VL = vector<LL>;        using VVL = vector<VL>;

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)
#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)
#define debug(x) cerr << #x << ": " << x << endl
const int INF = 1e9;                          const LL LINF = 1e9;
const LL MOD = 1000000007;                    const double PI = acos(-1.0);
int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };

/* -----  2018/06/12  Problem: AOJ 0596 / Link: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0596  ----- */
/* ------問題------

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 に到達するために必要な運賃の合計の最小値を求めるプログラムを作成せよ．

-----問題ここまで----- */
/* -----解説等-----

効率解法がない、うく
多重辺をはってしまった。うく

----解説ここまで---- */

int Dijkstra(const vector<vector<PLL>>& G, int s) {
	VL dist(SZ(G), INF);
	dist[s] = 0;
	priority_queue<PLL, vector<PLL>, greater<PLL>> que;
	que.push(PLL(0LL, s));

	while (!que.empty()) {
		PLL p = que.top(); que.pop();
		int v; /* 頂点*/ long long d; /* 頂点vまでの距離 */
		tie(d, v) = p;

		if (d > dist[v]) continue;

		FOR(i, 0, (int)G[v].size()) {
			int nv = G[v][i].first;
			if (dist[nv] > dist[v] + G[v][i].second) {
				dist[nv] = dist[v] + G[v][i].second;
				que.push(PLL(dist[nv], nv));
			}
		}
	}
	return dist[SZ(G)-1];
}
int main() {
	cin.tie(0);
	ios_base::sync_with_stdio(false);


	int N, E;
	cin >> N >> E;
	vector<vector<PII>>G(N);
	VVI infoG(N);
	vector<PII>Vinfo(N);
	FOR(i, 0, N) {
		int c, r; cin >> c >> r;
		Vinfo[i] = PII(c, r);
	}
	
	FOR(i, 0, E) {
		int a, b; cin >> a >> b;
		a--, b--;
		infoG[a].push_back(b);
		infoG[b].push_back(a);
	}
	FOR(base, 0, N) {
		VI visit(N, 0);
		queue<PII>q;
		int cost = Vinfo[base].first;
		int R = Vinfo[base].second;
		q.push(PII(base, 0));// r本たどった
		while (!q.empty()) {
			int v, r;
			tie(v, r) = q.front(); q.pop();
			if (visit[v])continue;
			visit[v] = 1;
			if (base != v) {
				G[base].push_back(PII(v, cost));
			}
			if (R>r) {
				FOR(i, 0, SZ(infoG[v])) {
					int nx = infoG[v][i];
					if (visit[nx])continue;
					q.push(PII(nx, r + 1));
				}
			}
		}
	}
	LL ans =Dijkstra(G,0);

	cout << ans << "\n";

	return 0;
}
accuracy: 1
time_ms: 590
memory_kb: 127928
final_rank: 20

code_snippet: #include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ull = unsigned long long;

const int INF = 1e9;
const ll LINF = 1e18;

#define rep(i,n) for (int i = 0; (i) < (n); (i)++)
#define rep1(i,n) for (int i = 1; (i) < ((n) + 1); (i)++)
#define all(a) (a).begin(), (a).end()

int main(){
  int N, K;
  cin >> N >> K;
  int C[10009], R[10009];
  rep1(i,N){
    cin >> C[i] >> R[i];
  }

  vector<int> V[10009];
  rep(i,K){
    int A, B;
    cin >> A >> B;
    V[A].push_back(B);
    V[B].push_back(A);
  }

  vector<int> G[10009];
  rep1(i,N){
    vector<int> d(10009,INF);
    d[i] = R[i];
    queue<int> Q;
    Q.push(i);
    while(!Q.empty()){
      int cur = Q.front();
      Q.pop();
        G[i].push_back(cur);
      if(d[cur] == 0) continue;

      for(const auto& nex : V[cur]){
        if(d[nex] != INF) continue;
        d[nex] = d[cur] - 1;
        Q.push(nex);
        G[cur].push_back(nex);
      }
    }
  }
  
  // rep1(i,N){
  //   rep(j,G[i].size()){
  //     cout << G[i][j] << " ";
  //   }
  //   cout << endl;
  // }
  bool visited[10009] = {};
  int dist[10009];
  rep1(i,N){
    dist[i] = INF;
  }
  dist[1] = 0;

  priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> Q;
  Q.push(make_pair(0,1));
  while(!Q.empty()){
    auto cur = Q.top().second;
    Q.pop();

    if(visited[cur] == true) continue;
    visited[cur] = true;

    int cost = dist[cur] + C[cur];
    for(const auto& nex : G[cur]){
      if(dist[nex] > cost){
        dist[nex] = cost;
        Q.push(make_pair(cost, nex));
      }
    }
  }
  // rep1(i,N){
  //   cout << i << ":" << dist[i] << endl;
  // }
  cout << dist[N] << endl;
}
accuracy: 1
time_ms: 420
memory_kb: 144152
final_rank: 18

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define ALL(A) A.begin(),A.end()
int main(){
    int N,M;cin>>N>>M;
    vector<int>C(N),R(N);
    for(int i=0;i<N;i++)cin>>C[i]>>R[i];
    vector<vector<int>>E(N);
    while(M--){
        int u,v;cin>>u>>v;u--;v--;
        E[u].emplace_back(v);
        E[v].emplace_back(u);
    }
    vector<vector<ll>>D(N,vector<ll>(N+1,1e18));
    D[0][R[0]]=C[0];
    priority_queue<pair<ll,pair<ll,ll>>>Q;
    Q.emplace(make_pair(-C[0],make_pair(0,R[0])));
    while(Q.size()){
        int v=Q.top().second.first,r=Q.top().second.second;
        ll d=-Q.top().first;
        Q.pop();
        if(d!=D[v][r])continue;
        if(D[v][R[v]]>d+C[v])D[v][R[v]]=d+C[v],Q.emplace(make_pair(-d-C[v],make_pair(v,R[v])));
        if(!r)continue;
        for(auto u:E[v])if(D[u][r-1]>d)D[u][r-1]=d,Q.emplace(make_pair(-d,make_pair(u,r-1)));
    }
    cout<<*min_element(ALL(D[N-1]))<<endl;
    return 0;
}
accuracy: 1
time_ms: 70
memory_kb: 199324
final_rank: 17

code_snippet: #include<bits/stdc++.h>

using namespace std;
using ll = long long;


int main() {

    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    ll N,K;
    cin>>N>>K;
    vector<vector<ll>> D(N,vector<ll>(N,1e16));
    vector<ll> C(N),R(N);
    for(int i=0;i<N;i++)cin>>C[i]>>R[i];
    vector<vector<int>> G(N);
    for(int i=0;i<K;i++){
        int u,v;
        cin>>u>>v;
        u--;v--;
        G[u].push_back(v);
        G[v].push_back(u);
    }    
    for(int i=0;i<N;i++){
        queue<int> Q;
        Q.push(i);
        vector<int> DD(N,R[i]+1);
        DD[i]=0;
        while(!Q.empty()){
            int p=Q.front();
            Q.pop();
            D[i][p]=min(D[i][p],C[i]);
            if(DD[p]==R[i])continue;
            for(auto v:G[p]){
                if(DD[v]<=DD[p]+1)continue;
                DD[v]=DD[p]+1;
                Q.push(v);
            }
        }
    }
    vector<ll> dist(N,1e18);
    dist[0]=0;
    vector<bool> seen(N,0);
    priority_queue<pair<ll,ll>,vector<pair<ll,ll>>,greater<pair<ll,ll>>> PQ;
    PQ.push({0,0});
    while(!PQ.empty()){
        ll c=PQ.top().first;
        ll n=PQ.top().second;
        PQ.pop();
        if(seen[n])continue;
        seen[n]=1;
        for(int v=0;v<N;v++){
            ll nc=c+D[n][v];
            if(seen[v])continue;
            if(dist[v]<=nc)continue;
            dist[v]=nc;
            PQ.push({nc,v});
        }
    }
    cout<<dist[N-1]<<endl;
}
accuracy: 1
time_ms: 400
memory_kb: 199632
final_rank: 19

code_snippet: #include <iostream>
#include <vector>
#include <queue>
#include <limits>
using namespace std;

typedef vector<int> vi;

vector<vi> pass;
vi c, r, d, used;

void dfs(int v, int u, int f, int end, vi& visited) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  for (int i = 0; i < pass[u].size(); i++) {
    dfs(v, pass[u][i], f + 1, end, visited);
  }
}

int dijk(int s, int g) {
  int n = pass.size();
  d.assign(n, numeric_limits<int>::max());
  used.assign(n, false);
  d[s] = 0;
  while (true) {
    int v = -1;
    for (int u = 0; u < n; u++) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    for (int i = 0; i < pass[v].size(); i++) {
      vi visited(n, false);
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}

int main() {
  int n, k;
  cin >> n >> k;
  c.resize(n);
  r.resize(n);
  pass.resize(n);
  for (int i = 0; i < n; i++) {
    cin >> c[i] >> r[i];
  }
  for (int i = 0; i < k; i++) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].push_back(b);
    pass[b].push_back(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 560
memory_kb: 3364
final_rank: 16

code_snippet: #include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000], r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 470
memory_kb: 3464
final_rank: 15

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3508
final_rank: 7

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  for(int i = 0; i < pass[u].size(); i++) { 
    dfs(v, pass[u][i], f + 1, end, visited); 
  }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    for(int i = 0; i < pass[v].size(); i++) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
  return 0;
}
accuracy: 1
time_ms: 430
memory_kb: 3576
final_rank: 11

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3472
final_rank: 5

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3548
final_rank: 8

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3568
final_rank: 10

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3576
final_rank: 11

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 5000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3436
final_rank: 4

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 440
memory_kb: 3576
final_rank: 14

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3612
final_rank: 13

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3552
final_rank: 9

code_snippet: #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  rep(i, pass[u].size()) { dfs(v, pass[u][i], f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v]))
        v = u;
    }
    if (v == -1)
      break;
    used[v] = true;
    rep(i, pass[v].size()) {
      bool visited[6000] = {};
      dfs(v, pass[v][i], 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 430
memory_kb: 3488
final_rank: 6

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
bool used[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u]) return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end) return;
  for (auto i : pass[u]) dfs(v, i, f + 1, end, visited);
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) if (!used[u] && (v == -1 || d[u] < d[v])) v = u;
    if (v == -1) break;
    used[v] = true;
    for (auto i : pass[v]) {
      bool visited[6000] = {};
      dfs(v, i, 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 380
memory_kb: 3788
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define pb push_back
const int INF = 1e9;
const int MAXN = 6000;
vector<int> pass[MAXN];
int n, k, c[MAXN], r[MAXN], d[MAXN];
bool used[MAXN];
void dfs(int v, int u, int f, int end, bool visited[MAXN]) {
  if (visited[u]) return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end) return;
  for (int i : pass[u]) dfs(v, i, f + 1, end, visited);
}
int dijk(int s, int g) {
  rep(i, MAXN) d[i] = INF;
  rep(i, MAXN) used[i] = false;
  d[s] = 0;
  while (1) {
    int v = -1;
    rep(u, n) {
      if (!used[u] && (v == -1 || d[u] < d[v])) v = u;
    }
    if (v == -1) break;
    used[v] = true;
    for (int i : pass[v]) {
      bool visited[MAXN] = {};
      dfs(v, i, 1, r[v], visited);
    }
  }
  return d[g];
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
  return 0;
}
accuracy: 1
time_ms: 390
memory_kb: 3584
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
vector<int> pass[6000];
int n, k;
int c[6000];
int r[6000];
int d[6000];
void dfs(int v, int u, int f, int end, bool visited[6000]) {
  if (visited[u])
    return;
  visited[u] = true;
  d[u] = min(d[u], d[v] + c[v]);
  if (f >= end)
    return;
  for (auto& i : pass[u]) { dfs(v, i, f + 1, end, visited); }
}
int dijk(int s, int g) {
  rep(i, 6000) d[i] = INF;
  rep(i, 6000) {
    bool used[6000] = {};
    d[s] = 0;
    while (1) {
      int v = -1;
      rep(u, n) {
        if (!used[u] && (v == -1 || d[u] < d[v]))
          v = u;
      }
      if (v == -1)
        break;
      used[v] = true;
      rep(j, pass[v].size()) {
        bool visited[6000] = {};
        dfs(v, pass[v][j], 1, r[v], visited);
      }
    }
    if (d[g] != INF)
      break;
  }
  return d[g];
}
int main() {
  cin.tie(0)->sync_with_stdio(false);
  cin >> n >> k;
  rep(i, n) cin >> c[i] >> r[i];
  rep(i, k) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    pass[a].pb(b);
    pass[b].pb(a);
  }
  cout << dijk(0, n - 1) << endl;
}
accuracy: 1
time_ms: 380
memory_kb: 3836
final_rank: 2