Problem:
Score : 600 points

Problem Statement

On the xy-plane, Snuke is going to travel from the point (x_s, y_s) to the point (x_t, y_t).
He can move in arbitrary directions with speed 1.
Here, we will consider him as a point without size.

There are N circular barriers deployed on the plane.
The center and the radius of the i-th barrier are (x_i, y_i) and r_i, respectively.
The barriers may overlap or contain each other.

A point on the plane is exposed to cosmic rays if the point is not within any of the barriers.

Snuke wants to avoid exposure to cosmic rays as much as possible during the travel.
Find the minimum possible duration of time he is exposed to cosmic rays during the travel.

Constraints

All input values are integers.

-10^9 ≤ x_s, y_s, x_t, y_t ≤ 10^9

(x_s, y_s) ≠ (x_t, y_t)

1≤N≤1,000

-10^9 ≤ x_i, y_i ≤ 10^9

1 ≤ r_i ≤ 10^9

Input

The input is given from Standard Input in the following format:

x_s y_s x_t y_t
N
x_1 y_1 r_1
x_2 y_2 r_2
:
x_N y_N r_N

Output

Print the minimum possible duration of time Snuke is exposed to cosmic rays during the travel.
The output is considered correct if the absolute or relative error is at most 10^{-9}.

Sample Input 1

-2 -2 2 2
1
0 0 1

Sample Output 1

3.6568542495

An optimal route is as follows:

Sample Input 2

-2 0 2 0
2
-1 0 2
1 0 2

Sample Output 2

0.0000000000

An optimal route is as follows:

Sample Input 3

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

Sample Output 3

4.0000000000

An optimal route is as follows:

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Diagnostics;
using static util;
using P = pair<int, int>;
using Number = System.Double;

class Program {
    static void Main(string[] args) {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        var solver = new Solver(sw);
        // var t = new Thread(solver.solve, 1 << 26); // 64 MB
        // t.Start();
        // t.Join();
        solver.solve();
        sw.Flush();
    }
}

class Solver {
    StreamWriter sw;
    Scan sc;
    void Prt(string a) => sw.WriteLine(a);
    void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
    void Prt(params object[] a) => Prt(string.Join(" ", a));
    public Solver(StreamWriter sw) {
        this.sw = sw;
        this.sc = new Scan();
    }

    public void solve() {
        int sx, sy, gx, gy;
        sc.Multi(out sx, out sy, out gx, out gy);
        int n = sc.Int;
        var p = new int[n + 2][];
        for (int i = 0; i < n; i++)
        {
            p[i] = sc.IntArr;
        }
        n += 2;
        p[n - 2] = new int[]{ sx, sy, 0 };
        p[n - 1] = new int[]{ gx, gy, 0 };
        var edge = new List<pair<double, int>>[n];
        for (int i = 0; i < n; i++)
        {
            edge[i] = new List<pair<double, int>>();
            for (int j = 0; j < n; j++)
            {
                if (i == j) continue;
                double c = Math.Max(Math.Sqrt((p[i][0] - p[j][0]) * (p[i][0] - p[j][0]) + (p[i][1] - p[j][1]) * (p[i][1] - p[j][1])) - p[i][2] - p[j][2], 0);
                edge[i].Add(new pair<double, int>(c, j));
            }
        }
        Prt(ShortestPath.Dijkstra(edge, n - 2)[n - 1]);
    }
}

class pair<T, U> : IComparable<pair<T, U>> {
    public T v1;
    public U v2;
    public pair() : this(default(T), default(U)) {}
    public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
    public int CompareTo(pair<T, U> a) {
        int c = Comparer<T>.Default.Compare(v1, a.v1);
        return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
    }
    public override string ToString() => v1 + " " + v2;
    public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
}
static class util {
    public static readonly int M = 1000000007;
    // public static readonly int M = 998244353;
    public static readonly long LM = 1L << 60;
    public static readonly double eps = 1e-11;
    public static void DBG(string a) => Console.Error.WriteLine(a);
    public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
    public static void DBG(params object[] a) => DBG(string.Join(" ", a));
    public static void Assert(bool cond) { if (!cond) throw new Exception(); }
    public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
    public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
        for (int i = 0; i < a.Count && i < b.Count; i++)
            if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
        return a.Count.CompareTo(b.Count);
    }
    public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
    static readonly int[] dd = { 0, 1, 0, -1 };
    // static readonly string dstring = "RDLU";
    public static P[] adjacents(int i, int j)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
    public static P[] adjacents(int i, int j, int h, int w)
        => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                         .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
    public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
    public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
    public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
        => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
    public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
    public static T[] inv<T>(this Dictionary<T, int> dic) {
        var res = new T[dic.Count];
        foreach (var item in dic) res[item.Value] = item.Key;
        return res;
    }
    public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
    public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
    public static T[] copy<T>(this IList<T> a) {
        var ret = new T[a.Count];
        for (int i = 0; i < a.Count; i++) ret[i] = a[i];
        return ret;
    }
}

class Scan {
    StreamReader sr;
    public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
    public Scan(string path) { sr = new StreamReader(path); }
    public int Int => int.Parse(Str);
    public long Long => long.Parse(Str);
    public double Double => double.Parse(Str);
    public string Str => sr.ReadLine().Trim();
    public pair<T, U> Pair<T, U>() {
        T a; U b;
        Multi(out a, out b);
        return new pair<T, U>(a, b);
    }
    public P P => Pair<int, int>();
    public int[] IntArr => StrArr.Select(int.Parse).ToArray();
    public long[] LongArr => StrArr.Select(long.Parse).ToArray();
    public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
    public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
    bool eq<T, U>() => typeof(T).Equals(typeof(U));
    T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
    T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                       : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                       : eq<T, double>() ? ct<T, double>(double.Parse(s))
                       : eq<T, char>()   ? ct<T, char>(s[0])
                                         : ct<T, string>(s);
    public void Multi<T>(out T a) => a = cv<T>(Str);
    public void Multi<T, U>(out T a, out U b)
    { var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); }
    public void Multi<T, U, V>(out T a, out U b, out V c)
    { var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); }
    public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d)
    { var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); }
    public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e)
    { var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]); }
}


static class ShortestPath {
    static Number Inf = util.LM;
    public static void WarshallFloyd(Number[][] g) {
        int n = g.Length;
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                for (int k = 0; k < n; ++k)
                    g[j][k] = Math.Min(g[j][k], g[j][i] + g[i][k]);
    }
    class Heap {
        int n;
        Number[] values;
        int[] keys, indices;
        public Heap(Number[] dist) {
            n = dist.Length;
            values = dist;
            keys = new int[n];
            for (int i = 0; i < n; i++) {
                keys[i] = i;
            }
            Array.Sort(keys, (x, y) => values[x].CompareTo(values[y]));
            indices = new int[n];
            for (int i = 0; i < n; i++) {
                indices[keys[i]] = i;
            }
        }
        void swap(int i, int j) {
            int t = keys[i]; keys[i] = keys[j]; keys[j] = t;
            indices[keys[i]] = i;
            indices[keys[j]] = j;
        }
        // int cmp(int i, int j) => values[keys[i]] > values[keys[j]] ? 1 : values[keys[i]] < values[keys[j]] ? -1 : 0;
        int cmp(int i, int j) => values[keys[i]].CompareTo(values[keys[j]]);

        // value[i] > a
        public void Update(int i, Number a) {
            values[i] = a;
            int j = indices[i];
            while (j > 0) {
                int k = (j - 1) >> 1;
                if (cmp(j, k) >= 0) break;
                swap(j, k);
                j = k;
            }
        }
        public int Pop() {
            --n;
            swap(0, n);
            int ret = keys[n];
            keys[n] = -1;
            indices[ret] = -1;
            for (int i = 0, j; (j = i << 1 | 1) < n; i = j) {
                if (j != n - 1 && cmp(j, j + 1) > 0) ++j;
                if (cmp(i, j) > 0) swap(i, j);
                else break;
            }
            return ret;
        }
        public int Top => keys[0];
        // public int Count => n;
    }


    public static Number[] Dijkstra(List<pair<Number, int>>[] edges, int s) {
        int n = edges.Length;
        var dist = new Number[n];
        for (int i = 0; i < n; ++i) dist[i] = Inf;
        dist[s] = 0;
        var q = new Heap(dist);
        while (q.Top != -1 && dist[q.Top] < Inf) {
            int p = q.Pop();
            foreach (var e in edges[p]) {
                Number d = dist[p] + e.v1;
                if (dist[e.v2] > d) {
                    q.Update(e.v2, d);
                }
            }
        }
        return dist;
    }
    public static Number[] Dijkstra(List<pair<Number, int>>[] edges, Number[] dist) {
        int n = edges.Length;
        var q = new Heap(dist);
        while (q.Top != -1 && dist[q.Top] < Inf) {
            int p = q.Pop();
            foreach (var e in edges[p]) {
                Number d = dist[p] + e.v1;
                if (dist[e.v2] > d) {
                    q.Update(e.v2, d);
                }
            }
        }
        return dist;
    }
    // public static Number[] Dijkstra(List<pair<Number, int>>[] edges, int s, out long[] cnt, long Mod) {
    //     int n = edges.Length;
    //     var dist = new Number[n];
    //     var q = new PriorityQueue<pair<Number, int>>(){ rev = true };
    //     for (int i = 0; i < n; ++i) dist[i] = Inf;
    //     dist[s] = 0;
    //     q.Push(new pair<Number, int>(dist[s], s));
    //     cnt = new long[n];
    //     cnt[s] = 1;
    //     while (q.Count > 0) {
    //         var p = q.Pop();
    //         if (dist[p.v2] < p.v1) continue;
    //         foreach (var e in edges[p.v2]) {
    //             Number d = p.v1 + e.v1;
    //             if (dist[e.v2] > d) {
    //                 dist[e.v2] = d;
    //                 cnt[e.v2] = cnt[p.v2];
    //                 q.Push(new pair<Number, int>(d, e.v2));
    //             }
    //             else if (dist[e.v2] == d) cnt[e.v2] = (cnt[e.v2] + cnt[p.v2]) % Mod;
    //         }
    //     }
    //     return dist;
    // }
}