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: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;


class Program
{
    public void Proc()
    {
        Reader.IsDebug = false;
        int[] inpt = Reader.ReadLine().Split(' ').Select(a => int.Parse(a)).ToArray();

        this.RoomCount = inpt[0];

        int roadCount = inpt[1];

        for (int i = 0; i < roadCount; i++)
        {
            inpt = Reader.ReadLine().Trim().Split(' ').Select(a => int.Parse(a)).ToArray();
            if (!roadDic.ContainsKey(inpt[0]))
            {
                roadDic.Add(inpt[0], new Dictionary<int, int>());
            }
            if (roadDic[inpt[0]].ContainsKey(inpt[1]))
            {
                roadDic[inpt[0]][inpt[1]] = Math.Min(roadDic[inpt[0]][inpt[1]], inpt[2]);
            }
            else
            {
                roadDic[inpt[0]].Add(inpt[1], inpt[2]);
            }

            if (!roadDic.ContainsKey(inpt[1]))
            {
                roadDic.Add(inpt[1], new Dictionary<int, int>());
            }
            if (roadDic[inpt[1]].ContainsKey(inpt[0]))
            {
                roadDic[inpt[1]][inpt[0]] = Math.Min(roadDic[inpt[1]][inpt[0]], inpt[2]);
            }
            else
            {
                roadDic[inpt[1]].Add(inpt[0], inpt[2]);
            }
        }

        this.SetMap();

        int queryCount = int.Parse(Reader.ReadLine());

        StringBuilder ans = new StringBuilder();
        for (int i = 0; i < queryCount; i++)
        {
            long[] linpt = Reader.ReadLine().Trim().Split(' ').Select(a => long.Parse(a)).ToArray();
            ans.AppendLine(this.GetAns(linpt[0], linpt[1]).ToString("##################################0"));
        }
        Console.Write(ans.ToString());
    }

    private int GetAns(long fromStart, long toGoal)
    {
        int ans = 0;
        int fromIdx = this.GetFromStartIndex(fromStart, 0, this.MapOrderFrom.Length - 1);
        int toIdx = this.GetGoalIndex(toGoal, MapOrderGoal, 0,this.MapOrderGoal.Length - 1);
        if (fromIdx < 0 || toIdx < 0)
        {
            ans = 0;
        }
        else
        {
            if (fromIdx <= toIdx)
            {
                ans = MapOrderFrom.Take(fromIdx + 1).Count(a => a.FarToGoal >= toGoal);
            }
            else
            {
                ans = MapOrderGoal.Take(toIdx + 1).Count(a => a.FarFromStart <= fromStart);
            }

        }
        return ans;
    }

    private int GetGoalIndex(long farToGoal, MapState[] mp, int min, int max)
    {
        if (mp[max].FarToGoal >= farToGoal)
        {
            return max;
        }
        if (mp[min].FarToGoal < farToGoal)
        {
            return -1;
        }
        int mid = (min + max) / 2;
        if (mp[mid].FarToGoal >= farToGoal)
        {
            if (max - mid <= 1)
            {
                return mid;
            }
            else
            {
                return GetGoalIndex(farToGoal, mp, mid, max);
            }
        }
        else if (mid - min <= 1)
        {
            return min;
        }
        else
        {
            return GetGoalIndex(farToGoal, mp, min, mid);
        }
    }

    private void SetMap()
    {
        MapState[] map = new MapState[this.RoomCount];
        map = map.Select(a => new MapState()).ToArray();

        map[0].FarFromStart = 0;
        Queue<int> taskQue = new Queue<int>();
        taskQue.Enqueue(0);
        while (taskQue.Count > 0)
        {
            int task = taskQue.Dequeue();

            if (this.roadDic.ContainsKey(task))
            {
                foreach (int nextPos in roadDic[task].Keys)
                {
                    if (nextPos == 0)
                    {
                        continue;
                    }
                    long nextVal = map[task].FarFromStart + roadDic[task][nextPos];
                    if (map[nextPos].FarFromStart < 0 || map[nextPos].FarFromStart > nextVal)
                    {
                        map[nextPos].FarFromStart = nextVal;
                        taskQue.Enqueue(nextPos);
                    }
                }
            }
        }

        map[RoomCount - 1].FarToGoal = 0;
        taskQue = new Queue<int>();
        taskQue.Enqueue(RoomCount - 1);
        while (taskQue.Count > 0)
        {
            int task = taskQue.Dequeue();
            if (this.roadDic.ContainsKey(task))
            {
                foreach (int nextPos in roadDic[task].Keys)
                {
                    if (nextPos == RoomCount - 1)
                    {
                        continue;
                    }
                    long nextVal = map[task].FarToGoal + roadDic[task][nextPos];
                    if (map[nextPos].FarToGoal < 0 || map[nextPos].FarToGoal > nextVal)
                    {
                        map[nextPos].FarToGoal = nextVal;
                        taskQue.Enqueue(nextPos);
                    }
                }
            }
        }
        this.MapOrderFrom = map.OrderBy(a=>a.FarFromStart).ToArray();
        this.MapOrderGoal = map.OrderByDescending(a => a.FarToGoal).ToArray();
    }

    private int GetFromStartIndex(long farFromStart, int min, int max)
    {
        if (farFromStart >= this.MapOrderFrom[max].FarFromStart)
        {
            return max;
        }
        int mid = (max + min) / 2;

        if (farFromStart >= MapOrderFrom[mid].FarFromStart)
        {
            if (max - mid <= 1)
            {
                return mid;
            }
            else
            {
                return this.GetFromStartIndex(farFromStart, mid, max);
            }
        }
        else if (mid - min <= 1)
        {
            return min;
        }
        else
        {
            return this.GetFromStartIndex(farFromStart, min, mid);
        }
    }

    private MapState[] MapOrderFrom;
    private MapState[] MapOrderGoal;
    public class MapState
    {
        public long FarFromStart = -1;
        public long FarToGoal = -1;
        
    }

    private Dictionary<int, Dictionary<int, int>> roadDic = new Dictionary<int, Dictionary<int, int>>();

    private int RoomCount;

    public class Reader
    {
        public static bool IsDebug = true;
        private static String PlainInput = @"


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


";
        private static System.IO.StringReader Sr = null;
        public static string ReadLine()
        {
            if (IsDebug)
            {
                if (Sr == null)
                {
                    Sr = new System.IO.StringReader(PlainInput.Trim());
                }
                return Sr.ReadLine();
            }
            else
            {
                return Console.ReadLine();
            }
        }
    }
    static void Main()
    {
        Program prg = new Program();
        prg.Proc();
    }
}