Problem:
Problem F : Dungeon (I)

あなたはとあるゲームの開発に携わっている。
そのゲームはランダムに生成されたダンジョンをプレイヤーが探索するというものである。

このゲームで生成されるダンジョンにはn 個の部屋が存在しており、0から n-1 までの番号が割り振られている。
部屋と部屋は通路で結ばれている。部屋と部屋を結ぶ通路は、m 本ある。
通路はどちらの方向へも進むことができる。
また、部屋と部屋の間には距離が設定されている。
生成されたダンジョンではいくつかの通路を経由して、ある部屋から他のすべての部屋へ行くことが可能である。
そして、プレイヤーがゲームを行う際に、0番の部屋がスタート地点、n-1 番の部屋がゴール地点として選ばれる。

ユーザーがダンジョンを探索する際に、手助けになるようなアイテムが入った宝箱を、どこかの部屋に設置したい。
その時に、スタート地点から遠すぎたり、ゴール地点から近すぎると意味がない。
そこで、スタートから距離 fs 以内で辿りつけて、ゴールに辿り着くために最短経路を通った場合に、少なくとも fg かかる部屋を宝箱を設置する候補としたい。

生成されたダンジョンと、q が与えられる。q 個のクエリーについて、宝箱を設置する場所の候補の数を数えて欲しい。

Input

入力は以下のフォーマットで与えられる。

n m
a1 b1 c1
.
.
.
am bm cm
q
fs1 fg1
.
.
.
fsq fgq

ai bi ci は 部屋 ai と bi　を結ぶ通路の距離がciであることを表す。

入力は以下の制約を満たす

2 ≤ n ≤ 100,000

0 ≤ ai , bi < n

0 ≤ ci ≤ 100,000

n-1 ≤ m ≤ 100,000

1 ≤ q ≤ 100,000

0 ≤ fsi , fgi ≤ 260

Output

各クエリーについて、答えの値を1行に出力せよ

Sample Input 1

4 4
0 1 3
1 3 4
0 2 2
2 3 1
4
0 0
2 2
2 1
3 4

Sample Output 1

1
1
2
1

Solution in C++ (judge verdict: Wrong Answer)

#include<iostream>
#include<map>
#include<vector>
#include<queue>
#include<functional>
#include<algorithm>
using namespace std;
#define INF (1LL << 61)

long long froms[105000], fromg[105000], fs, fg;
map<int, long long> edge[105000];
vector<int> bit[105000];
int n, m, a, b, c, q;

void dijkstra(long long *dist, int start){
  dist[start] = 0;
  priority_queue<pair<long long , int>, vector<pair<long long , int> >, greater<pair<long long , int> > > pque;
  pque.push(make_pair(0, start));
  while(!pque.empty()){
    pair<long long , int> tmp = pque.top(); pque.pop();
    if(dist[tmp.second] < tmp.first)continue;
    map<int, long long >::iterator it = edge[tmp.second].begin();
    while(it != edge[tmp.second].end()){
      if( (*it).second + dist[tmp.second] < dist[(*it).first]){
	dist[(*it).first] = (*it).second + dist[tmp.second];
	pque.push(make_pair(dist[(*it).first], (*it).first));
      } 
      it++;
    }
  }
}

bool compgole(const int &a, const int &b){
  return fromg[a] > fromg[b];
};

bool compstart(const int &a, const int &b){
  return froms[a] < froms[b];
};

void add(int x, int y){
  while(x <= n){
    bit[x].push_back(y);
    x += x & -x;
  }
}

int solve(int x){
  int res = 0;
  while(x){
    res += upper_bound(bit[x].begin(), bit[x].end(), 103000, compstart) - bit[x].begin();
    x -= x & -x;
  }
  return res;
}

int main(){
  cin >> n >> m;
  fill(froms, froms + 105000, INF);
  fill(fromg, fromg + 105000, INF);
  for(int i = 0;i < m;i++){
    cin >> a >> b >> c;
    edge[a][b] = edge[b][a] = c;
  }
  dijkstra(froms, 0);
  dijkstra(fromg, n - 1);
  vector<int> chambers;
  for(int i = 0;i < n;i++){
    chambers.push_back(i);
  }
  sort(chambers.begin(), chambers.end(), compgole);
  for(int i = 0;i < n;i++){
    add(i + 1, chambers[i]);
  }
  for(int i = 1;i <= n;i++){
    sort(bit[i].begin(), bit[i].end(), compstart);
  }
  cin >> q;
  for(int i = 0;i < q;i++){
    cin >> froms[103000] >> fromg[103000];
    int p = upper_bound(chambers.begin(), chambers.end(), 103000, compgole) - chambers.begin();
    cout << solve(p) << endl;
  }
  return 0;
}