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


namespace AtCoder
{
    static class Extensions
    {
        public static int LowerBound<T>(this IList<T> list, T value, IComparer<T> comp=null)
        {
            if (comp == null) comp = Comparer<T>.Default;

            var l = 0;
            var r = list.Count;

            while (l < r)
            {
                var m = (l + r) / 2;
                var c = comp.Compare(value, list[m]);
                if (c > 0) l = m + 1;
                else  r = m;
            }

            return l;
        }
        public static int UpperBound<T>(this IList<T> list, T value, IComparer<T> comp=null)
        {
            if (comp == null) comp = Comparer<T>.Default;

            var l = 0;
            var r = list.Count;

            while (l < r)
            {
                var m = (l + r) / 2;
                var c = comp.Compare(value, list[m]);
                if (c >= 0) l = m + 1;
                else r = m;
            }

            return r;
        }
    }
    class Program
    {
		static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        static int[] ReadIntArray(int n)
        {
            var a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = ReadInt();
            }
            return a;
        }
        static long[] ReadLongArray()
        {
            return Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }
        static long[] ReadLongArray(int n)
        {
            var a = new long[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = ReadLong();
            }
            return a;
        }
		
        public static int[] ZAlgotithm(string s)
        {
            var len = s.Length;

            var a = new int[len];
            a[0] = len;
            var i = 1;
            var j = 0;
            while (i < len)
            {
                while (i + j < len && s[j] == s[i + j]) j++;
                a[i] = j;

                if (j == 0)
                {
                    i++;
                    continue;
                }

                var k = 1;
                while (i + k < len && k + a[k] < j)
                {
                    a[i + k] = a[k];
                    k++;
                }
                i += k;
                j -= k;
            }

            return a;
        }
        public class MaxHeap<T> : IEnumerable<T>
        {
            private List<T> _list;
            private Comparer<T> _comp;
			
            public int Count
            {
                get
                {
                    return _list.Count;
                }
            }
            public MaxHeap() : this(0) { }
            public MaxHeap(int capacity, Comparison<T> comp=null)
            {
                _list = new List<T>(capacity);

                if (comp == null)
                {
                    _comp = Comparer<T>.Default;
                }
                else
                {
                    _comp = Comparer<T>.Create(comp);
                }
            }
            
            public void Push(T elem)
            {
                Upheap(elem);
            }

            public T Pop()
            {
                return Downheap();
            }

            public T Peek()
            {
                return _list[0];
            }

            
            private void Swap(int i, int j)
            {
                var a = _list[j];
                _list[j] = _list[i];
                _list[i] = a;
            }

            private void Upheap(T elem)
            {
                _list.Add(elem);
                var i = _list.Count - 1;

                while (true)
                {
                    if (i == 0) return;
                    var j = (i - 1) / 2;

                    var e = _list[i];
                    var p = _list[j];

                    var c = _comp.Compare(e, p);
                    if (c > 0)
                    {
                        Swap(i, j);
                        i = j;
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            private T Downheap()
            {
                var result = _list[0];

                var last = _list.Count - 1;
                Swap(0, last);
                _list.RemoveAt(last);
                if (_list.Count == 0) return result;

                var i = 0;
                while (true)
                {
                    if (i == _list.Count - 1) return result;
                    var p = _list[i];

                    var j = i * 2 + 1;
                    if (j >= _list.Count) return result;

                    if(j+1 < _list.Count && _comp.Compare(_list[j], _list[j+1]) < 0)
                    {
                        j++;
                    }

                    if (_comp.Compare(_list[i], _list[j]) < 0)
                    {
                        Swap(i, j);
                        i = j;
                    }
                    else
                    {
                        return result;
                    }
                }
            }
            public MaxHeap<T> Copy(Comparison<T> comp=null)
            {
                var c = new MaxHeap<T>(0, comp);
                c._list = _list.ToList();

                return c;
            }
            public MaxHeap(List<T> list)
            {
                _list = list;

                _comp = Comparer<T>.Default;
            }

            public List<T> GetList()
            {
                return _list;
            }

            public IEnumerator<T> GetEnumerator()
            {
                return _list.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
        class InputLine
        {
            private string[] _inputs;
            private int _index = 0;

            InputLine(string input)
            {
                _inputs = input.Split();
                _index = 0;
            }

            public static InputLine Read()
            {
                return new InputLine(Console.ReadLine());
            }

            public int NextInt()
            {
                return int.Parse(_inputs[_index++]);
            }
            public long NextLong()
            {
                return long.Parse(_inputs[_index++]);
            }
            public double NextDouble()
            {
                return double.Parse(_inputs[_index++]);
            }
        }
        public static int GCD(int x, int y)
        {
            var a = Math.Max(x, y);
            var b = x + y - a;

            while (b != 0)
            {
                var c = b;
                b = a % b;
                a = c;
            }

            return a;
        }
        public static long GCD(long x, long y)
        {
            var a = Math.Max(x, y);
            var b = x + y - a;

            while (b != 0)
            {
                var c = b;
                b = a % b;
                a = c;
            }

            return a;
        }
        static long ModPower(long x, long y, long mod)
        {
            var bytes = BitConverter.GetBytes(y);
            var bits = new System.Collections.BitArray(bytes);

            var max2 = 0;
            for (int i = bits.Length - 1; i >= 0; i--)
            {
                if (bits[i])
                {
                    max2 = i;
                    break;
                }
            }

            long result = 1;
            for (int i = max2; i >= 0; i--)
            {
                result = (result * result) % mod;
                if (bits[i])
                {
                    result = (result * x) % mod;
                }
            }

            return result;
        }
        
        static long ModFact(long n, long mod)
        {
            long result = 1;

            for (int i = 1; i <= n; i++)
            {
                result = result * i % mod;
            }
            return result;
        }
		
        static long ModAdd(long x, long y, long mod)
        {
            return ((x % mod) + (y % mod)) % mod;
        }
        static long ModMal(long x, long y, long mod)
        {
            return ((x % mod) * (y % mod)) % mod;
        }

        static long ModDiv(long x, long y, long mod)
        {
            //フェルマーの小定理より、a^(-1) = a^(p-2)
            return ModMal(x, ModPower(y, mod - 2, mod), mod);
        }
        static long ModComb(long n, long r, long mod)
        {
            long numerator = 1;
            for (int i = 0; i < r; i++)
            {
                numerator = ModMal(numerator, n - i, mod);
            }

            long denominator = ModFact(r, mod);

            return ModDiv(numerator, denominator, mod);
        }
        class Graph
        {
            private int _size;
            private List<int>[] _map;

            public IEnumerable<int> this[int i]
            {
                get
                {
                    if (_map[i] == null) return Enumerable.Empty<int>();
                    return _map[i];
                }
            }

            public Graph(int size)
            {
                _size = size;
                _map = new List<int>[size];
            }

            public void Add(int from, int to)
            {
                if (_map[from] == null)
                {
                    _map[from] = new List<int>();
                }
                _map[from].Add(to);
            }
        }
        static long p1097 = 1000000007;
        static void Main(string[] args)
        {
			//↓

            var nm = ReadIntArray();
            var n = nm[0];
            var m = nm[1];
            var sts = new int[m, 2];

            var edges = new List<int>[n];
            for (int i = 0; i < n; i++)
            {
                edges[i] = new List<int>();
            }

            for (int i = 0; i < m; i++)
            {
                var st = ReadIntArray();
                edges[st[0] - 1].Add(st[1] - 1);
            }

            var min = double.MaxValue;
            for (int j = 0; j <= n; j++)
            {
                var exs = new double[n];
                exs[n - 1] = 0;

                for (int i = n - 2; i >= 0; i--)
                {
                    var e = edges[i];

                    var sum = 0d;
                    var max = -1d;
                    for (int k = 0; k < e.Count; k++)
                    {
                        var ex = exs[e[k]] + 1;
                        sum += ex;
                        max = Math.Max(max, ex);
                    }
                    var c = e.Count;

                    if (i == j && e.Count > 1)
                    {
                        sum -= max;
                        c -= 1;
                    }

                    exs[i] = sum / c;
                }

                min = Math.Min(exs[0], min);
            }

            Console.WriteLine(min);


			//↑
        }

	}
}

Measured memory_bytes: 19844