G. Team Players

直接上容斥，
然后暴力判断。
搞定…
c++ 代码如下：

#include<bits/stdc++.h>
#define lowbit(x) (x & -x)
#define rep(i,x,y) for(register int i = x ;i <= y; ++ i)
#define repd(i,x,y) for(register int i = x ; i >= y; -- i)
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
template<typename T>inline void read(T&x)
{
    char c;int sign = 1;x = 0;
    do { c = getchar(); if(c == '-') sign = -1; }while(!isdigit(c));
    do { x = x * 10 + c - '0'; c = getchar(); }while(isdigit(c));
    x *= sign;
}

const int N = 2e5 + 20;
ull a,b,c,n,m;
ull u[N],v[N],ans;
ull s1[N],s2[N],s3[N];
vector<int> g[N],f[N];

int main()
{
    read(n); read(m);
    read(a); read(b); read(c);
    rep(i,1,m)
    {
        read(u[i]); read(v[i]);
        if(u[i] > v[i]) swap(u[i],v[i]);
        g[u[i]].push_back(v[i]);
        f[v[i]].push_back(u[i]);
    }

    rep(i,0,n-1)
    {
        ull x = n - i - 1;
        ans += a * i * (x * (x - 1) / 2);
        ans += b * i * i * x;
        ans += c * i * ((ull)i * (i - 1) / 2);
    }

    rep(i,1,m)
    {
        s1[  0 ] += 1;
        s1[u[i]] -= 1;

        s1[ u[i] ] += n - u[i] - 2;
        s1[u[i]+1] -= n - u[i] - 2;

        s2[u[i]+1] += 1;
        s2[ v[i] ] -= 1;

        s2[ u[i] ] += u[i];
        s2[u[i]+1] -= u[i];

        s2[ v[i] ] += n - v[i] - 1;
        s2[v[i]+1] -= n - v[i] - 1;

        s3[v[i]+1] += 1;
        s3[  n   ] -= 1;

        s3[ v[i] ] += v[i] - 1;
        s3[v[i]+1] -= v[i] - 1;
    }

    rep(i,1,n) 
        s1[i] += s1[i - 1],
        s2[i] += s2[i - 1],
        s3[i] += s3[i - 1];

    rep(i,0,n - 1)
    {
        ans -= a * i * s1[i];
        ans -= b * i * s2[i];
        ans -= c * i * s3[i];
    }

    rep(i,0,n-1) sort(g[i].begin(),g[i].end());
    rep(i,0,n-1) sort(f[i].begin(),f[i].end());
    rep(i,0,n-1)
    {
        int sz = g[i].size();
        rep(j,0,sz - 1)
        {
            int k = j + 1;
            while(k < sz)
            {
                ans += a * i;
                ans += b * g[i][j];
                ans += c * g[i][k];
                k ++ ;
            }

            int SZ = g[g[i][j]].size();
            rep(q,0,SZ - 1)
            {
                ans += a * i;
                ans += b * g[i][j];
                ans += c * g[g[i][j]][q];
            }
        }

        sz = f[i].size();
        rep(j,0,sz - 1)
        {
            int k = j + 1;
            while(k < sz)
            {
                ans += a * f[i][j];
                ans += b * f[i][k];
                ans += c * i;
                ++ k;
            }
        }
    }

    rep(i,0,n-1)
    {
        int sz = g[i].size();
        rep(j,0,sz - 1)
        {
            int t = j + 1,k = 0;
            int SZ = g[g[i][j]].size();
            while(t < sz && k < SZ)
            {
                if(g[i][t] == g[g[i][j]][k])
                {
                    ans -= a * i;
                    ans -= b * g[i][j];
                    ans -= c * g[i][t];
                    ++ t; ++ k;
                }
                else if(g[i][t] < g[g[i][j]][k]) ++ t;
                else ++ k;
            }
        }
    }

    cout << ans << endl;

    return 0;
}