#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define all(x) begin(x), end(x)
#define sz(x) (int) (x).size()
typedef pair<int, int> pii;
struct comp {
    bool operator()(const pii& a, const pii& b) const {
        if (a.first != b.first) return a.first < b.first;
        return a.second < b.second;
    }
};
typedef tree<pii, null_type, comp, rb_tree_tag, tree_order_statistics_node_update> ordered_multiset;

int k, n;
vector<array<int, 2>> bg;
vector<int> dcd;
int ans = 0;

bool ccb(const array<int, 2> &a, const array<int, 2> &b) {
    return (dcd[a[0]] + dcd[a[1]] < dcd[b[0]] + dcd[b[1]]);
}

struct FT {
    vector<int> s;
    FT(int n) : s(n, 0) {}
    void init() {
        fill(all(s),0);
    }
    void update(int pos, int dif) { // a[pos] += dif
        for (; pos < sz(s); pos |= pos + 1) s[pos] += dif;
    }
    int query(int pos) { // sum of values in [0, pos)
        int res = 0;
        for (; pos > 0; pos &= pos - 1) res += s[pos - 1];
        return res;
    }
    int query(int l, int r) {
        if (l) {
            return query(r + 1) - query(l);
        } else {
            return query(r + 1);
        }
    }
};

void solve1() {
    if (!sz(bg)) {
        cout << ans;
        return;
    }
    FT amt(sz(dcd) + 1);
    FT val(sz(dcd) + 1);
    ordered_multiset pt;
    int cind = 0;
    for (auto i : bg) {
        pt.insert({i[0], cind++});
        pt.insert({i[1], cind++});
        amt.update(i[0], 1);
        val.update(i[0], dcd[i[0]]);
        amt.update(i[1], 1);
        val.update(i[1], dcd[i[1]]);
    }
    int m = (*pt.find_by_order(sz(pt) / 2)).first;
    int mv = dcd[m];
    int pmt = amt.query(0, m), pvl = val.query(0, m);
    int nmt = amt.query(m + 1, sz(dcd)), nvl = val.query(m + 1, sz(dcd));
    cout << ans + pmt * mv - pvl + nvl - nmt * mv;
}

void solve2() {
    if (sz(bg) < 2) {
        cout << ans;
        return;
    }
    FT amt(sz(dcd) + 1);
    FT val(sz(dcd) + 1);
    ordered_multiset pt;
    int cind = 0;
    vector<int> sv; sv.resize(n);
    for (int i=0; i<n; i++) {
        int u=bg[i][0], v=bg[i][1];
        pt.insert({u,cind++});
        pt.insert({v,cind++});
        amt.update(u, 1);
        val.update(u, dcd[u]);
        amt.update(v, 1);
        val.update(v, dcd[v]);
        int m = (*pt.find_by_order(sz(pt) / 2)).first;
        int mv = dcd[m];
        int pmt = amt.query(0, m), pvl = val.query(0,m );
        int nmt = amt.query(m + 1, sz(dcd)), nvl = val.query(m + 1, sz(dcd));
        sv[i]=pmt*mv-pvl+nvl-nmt*mv;
    }
    vector<int> pv; pv.resize(n);
    amt.init(); val.init();
    ordered_multiset vt; cind=0;
    for (int i=n-1; i>=0; i--) {
        int u=bg[i][0], v=bg[i][1];
        vt.insert({u,cind++});
        vt.insert({v,cind++});
        amt.update(u, 1);
        val.update(u, dcd[u]);
        amt.update(v, 1);
        val.update(v, dcd[v]);
        int m = (*vt.find_by_order(sz(vt) / 2)).first;
        int mv = dcd[m];
        int pmt = amt.query(0, m), pvl = val.query(0,m );
        int nmt = amt.query(m + 1, sz(dcd)), nvl = val.query(m + 1, sz(dcd));
        if (i==n-1) {
     //       cout << dcd[u] << " " << dcd[v] << ":\n";
     //       cout << m << " " << mv << " " << pmt << " " << nmt << "\n";
        }
        pv[i]=pmt*mv-pvl+nvl-nmt*mv;
    }
    int res=1e18;
    for (int i=0; i+1<n; i++) {
        res=min(res,sv[i]+pv[i+1]);
    //    cout << sv[i] << " " << pv[i+1] << "\n";
    }
 //   cout << ans << "\n";
    cout<<res+ans;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> k >> n;
    for (int i = 0; i < n; i++) {
        char t1, t2;
        int p1, p2;
        cin >> t1 >> p1 >> t2 >> p2;
        if (t1 == t2) {
            ans += abs(p1 - p2);
        } else {
            ans += 1;
            bg.push_back({p1, p2});
            dcd.push_back(p1);
            dcd.push_back(p2);
        }
    }
    n = sz(bg);
    sort(all(dcd));
    dcd.erase(unique(all(dcd)), dcd.end());
    for (int i = 0; i < n; i++) {
        bg[i][0] = lower_bound(all(dcd), bg[i][0]) - dcd.begin();
        bg[i][1] = lower_bound(all(dcd), bg[i][1]) - dcd.begin();
    }
    sort(all(bg), ccb);

    if (k == 1) {
        solve1();
    } else {
        solve2();
    }

    return 0;
}