RT.
做法是二分答案，然后判定，参照题解。

#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
using namespace std;
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define REP(i, a, b) for (int i = a; i >= b; i--)
#define pb push_back
#define eb emplace_back
#define popcount __builtin_popcount
#define ctz __builtin_ctz
#define gc getchar()
#define mkpr make_pair
#define i128 __int128
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
typedef std::pair<ll, ll> pll;
template <class T>
void write(T x)
{
    if (x < 0)
    {
        putchar('-');
        x = -x;
    }
    if (x >= 10)
    {
        write(x / 10);
    }
    putchar(x % 10 ^ 48);
}
template <class T>
void read(T &x)
{
    x = 0;
    T f = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= f;
}
template <class T>
T quick_pow(T a, T b, T p = -1)
{
    if (p == -1)
    {
        T res = 1;
        while (b)
        {
            if (b & 1)
                res = res * a;
            a *= a;
            b >>= 1;
        }
        return res;
    }
    else
    {
        T res = 1;
        while (b)
        {
            if (b & 1)
                res = res * a % p;
            a = a * a % p;
            b >>= 1;
        }
        return res;
    }
}
template <class T>
T inv(T x, T p) { return quick_pow(x, p - 2, p); }
ll qpow(ll a, ll b, ll mod)
{
    ll res = 1;
    while (b)
    {
        if (b & 1)
            res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}
ll invll(ll a,ll mod)
{
    return qpow(a,mod-2,mod);
}
struct Matrix
{
    vector<vector<ll>> mp;
    ll p;
    int size;
    // 第二个参数：是否设为单位矩阵
    void init(int siz, ll mod = -1, bool isdw = 0)
    {
        p = mod;
        size = siz;
        mp.resize(siz);
        for (int i = 0; i < siz; i++)
        {
            mp[i].resize(siz);
            for (int j = 0; j < siz; j++)
            {
                mp[i][j] = 0;
            }
            if (isdw)
                mp[i][i] = 1;
        }
    }
    Matrix operator*(const Matrix &b)
    {
        Matrix res;
        res.init(max(size, b.size), p);
        for (int i = 0; i < size; i++)
        {
            for (int k = 0; k < size; k++)
            {
                for (int j = 0; j < size; j++)
                {
                    if (k >= b.size || j >= b.size)
                    {
                        continue;
                    }
                    res.mp[i][j] += mp[i][k] * b.mp[k][j];
                    if (res.p != -1)
                        res.mp[i][j] %= res.p;
                }
            }
        }
        return res;
    }
};
Matrix quick_pow_mat(Matrix a, ll b)
{
    Matrix res;
    res.init(a.size, a.p, 1);
    while (b)
    {
        if (b & 1)
            res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}
mt19937 rnd(random_device{}());
template <const int mod>
class static_mint
{
public:
    int mval=0,minv=-1;
    static_mint()
    {
        mval = 0;
        minv = -1;
    }
    static_mint(int val)
    {
        this->mval = val % mod;
        this->minv = -1;
    }
    int val()
    {
        return mval;
    }
    int inv()
    {
        if (minv != -1)
            return minv;
        else
            return minv = qpow(mval, mod - 2, mod);
    }
    static_mint operator =(int b)
    {
        this->mval=b%mod;
        this->minv=-1;
        return *this;
    }
    operator int()
    {
        return int(mval);
    }
    operator ll()
    {
        return ll(mval);
    }
    operator double()
    {
        return (double)(mval);
    }
    operator float()
    {
        return (float)(mval);
    }
    bool operator!=(static_mint b)
    {
        return mval!=b.val();
    }
    static_mint operator+(static_mint b)
    {
        return static_mint((1ll*mval + b.val()) % (ll)mod);
    }
    static_mint operator-(static_mint b)
    {
        int res = (1ll*mval - b.val()) % (ll)mod + mod;
        if (res >= mod)
            res -= mod;
        return static_mint(res);
    }
    static_mint operator*(static_mint b)
    {
        int res = 1ll * mval * b.val() % (ll)mod;
        return static_mint(res);
    }
    static_mint operator/(static_mint b)
    {
        int res = 1ll * mval * b.inv() % (ll)mod;
        return static_mint(res);
    }
    static_mint operator+=(static_mint b)
    {
        mval = (1ll*mval + b.val()) % (ll)mod;
        minv = -1;
        return *this;
    }
    static_mint operator-=(static_mint b)
    {
        mval = (1ll*mval - b.val()) % (ll)mod + mod;
        if (mval >= mod)
            mval -= mod;
        minv = -1;
        return *this;
    }
    static_mint operator*=(static_mint b)
    {
        mval = 1ll * mval * b.val() % (ll)mod;
        minv = -1;
        return *this;
    }
    static_mint operator/=(static_mint b)
    {
        mval = 1ll * mval * b.inv() % (ll)mod;
        minv = -1;
        return *this;
    }
    // ===========================
    // b's type = int
    static_mint operator+(int b)
    {
        return static_mint((1ll*mval + b) % (ll)mod);
    }
    static_mint operator-(int b)
    {
        int res = (1ll*mval - b) % (ll)mod + mod;
        if (res >= mod)
            res -= mod;
        return static_mint(res);
    }
    static_mint operator*(int b)
    {
        int res = 1ll * mval * b % (ll)mod;
        return static_mint(res);
    }
    static_mint operator/(int b)
    {
        int res = 1ll * mval * invll(b,mod) % (ll)mod;
        return static_mint(res);
    }
    static_mint operator+=(int b)
    {
        mval = (1ll*mval + b) % (ll)mod;
        minv = -1;
        return *this;
    }
    static_mint operator-=(int b)
    {
        mval = (1ll*mval - b) % (ll)mod + mod;
        if (mval >= mod)
            mval -= mod;
        minv = -1;
        return *this;
    }
    static_mint operator*=(int b)
    {
        mval = 1ll * mval * b % (ll)mod;
        minv = -1;
        return *this;
    }
    static_mint operator/=(int b)
    {
        mval = 1ll * mval *invll(b,mod) % (ll)mod;
        minv = -1;
        return *this;
    }
    bool operator!=(int b)
    {
        return mval!=b;
    }
};
const int maxn=2e5+5;
int n,m;
int head[maxn];
struct EDGE
{
    int to,nxt;
    ll b,c;
}edge[maxn];
int cnt;
void add(int u,int t,ll b,ll c)
{
    edge[++cnt].to=t;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
    edge[cnt].b=b;
    edge[cnt].c=c;
}
double dis[maxn];
bool vis[maxn];
bool dij(double x)
{
    memset(vis,0,sizeof vis);
    memset(dis,0xfe,sizeof dis);
    priority_queue<pair<double,int>> que;
    que.push(make_pair(0.0,1));
    dis[1]=0.0;
    while(!que.empty())
    {
        int u=que.top().second;
        que.pop();
        if(vis[u])continue;
        vis[u]=1;
      //  printf("u = %d\n",u);
        for(int i=head[u];i;i=edge[i].nxt)
        {
            int to=edge[i].to;
            if(dis[u]+double(edge[i].b)-double(edge[i].c)*x>dis[to])
            {
                dis[to]=dis[u]+double(edge[i].b)-double(edge[i].c)*x;
                que.push(make_pair(dis[to],to));
            }
        }
    }
  //  printf("x = %.5lf dis[%d] = %.5lf\n",x,n,dis[n]);
    return dis[n]>=0;
}
int main()
{
    scanf("%d%d",&n,&m);
    FOR(i,1,m)
    {
        int u,v;
        ll b,c;
        scanf("%d%d%lld%lld",&u,&v,&b,&c);
        add(u,v,b,c);
    }
    double l=0,r=2e9;
  //  printf("l = %.10lf r = %.10lf\n",l,r);
    FOR(_,1,100)
    {
        double mid=(l+r)/2.0;
        if(dij(mid))l=mid;
        else r=mid;
    }
    printf("%.10lf",l);
    return 0;
}