JZOJ 5803. 【2018.8.12省选模拟】girls

 

A,B,C<=1e6

保证冲突关系中的x不等于y

---

设$f(i)$表示不满足条件的对数至少有$i$对时的答案

则$ans=f(0)-f(1)+f(2)-f(3)$

---

稍微解释一下，如果$(0,1),(1,2)$属于不能在一起的集合的话

在$f(0)$中，$(0,1,2)$会被加上一遍

在$f(1)$中，$(0,1,2)$会被减去两遍，分别在$(0,1,*),(*,1,2)$中统计到

在$f(2)$中，$(0,1,2)$会被加上一遍

在$f(3)$中，不会计算到

然后成功将答案容斥对了

---

计算$f(0)$

枚举$0 \le i \le n-1$，统计$i$在每个位置（三种情况，$(j,k,i),(j,i,k),(i,j,k)$）上出现次数

1. 对于$(j,k,i)$，出现次数为$C_{i}^{2}$

2. 对于$(j,i,k)$，出现次数为$i \times (n - i - 1)$

3. 对于$(i,j,k)$，出现次数为$C_{n-i-1}^{2}$

然后乘上对应的系数（三种情况，$A \times i, B \times i, C \times i$），累加起来就是$f(0)$了

---

计算$f(1)$

直接枚举不合法关系$(x,y)$，分别讨论$(x,y,z),(x,z,y),(z,x,y)$三种情况

---

计算$f(2)$

对于不合法的关系$(x,y)$，视作$x$和$y$之间有一条无向边

每个点维护两个$vector$，分别存储与该点相连，编号小于该点的点，以及编号大于该点的点

这样一来至少有两对不合法的方案就一共有三种（假设当前枚举到了$x$，其中$(y,z)$是$x$相邻中的点）

对于前两种情况，可以将两个$vector$排序后边计算前/后缀和，边统计答案

对于第三种情况，直接统计贡献即可

---

计算$f(3)$

即统计图上三元环的个数，方法如下：

1. 对于不合法关系$(x,y)$，连无向边$(x,y)$

2. 对于所有的无向边，将其定向：如果$u$和$v$的度数不相同，则边的方向为度数大的朝向度数小的，否则编号小的朝向编号大的，此时这张图是一个$DAG$

3. 开一个全局$vis$数组，大小为点的个数

4. 枚举了$x$，将$x$所有出点在$vis$数组中标为$1$

5. 枚举$x$的所有出点$y$，然后枚举所有出点$z$，如果$z$在$vis$数组中被标为$1$，那么$(x,y,z)$就是一个三元环

6. 将$vis$数组清空

7. 继续枚举，直到整张图的点都枚举过

时间复杂度大约为$O(m \sqrt n)$

---

关于此题容斥的正确性可以这么证明：

设一个三元组$(x,y,z)$，其中$x \lt y \lt z$且存在$k$对不合法关系

则对答案的贡献为$g(0)-g(1)+g(2)-g(3)=1-k+C_{k}^{2}-[k=3]=[k=0]$

---

#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
const int N = 2e5 + 10;
struct REL { int x, y; } rel[N];
int n, m;
ull A, B, C, cnt[4], ans;
vector<int> lt[N], gt[N], g[N];
int deg[N], vis[N];
ull sumA[N], sumB[N], sumC[N];

ull calc1(int x, int y) {
    if(x > y) swap(x, y);
    ull res = 0;
    if(x > 0) res += sumA[x - 1] + x * (B * x + C * y);
    if(x + 1 < y) res += (y - x - 1) * (A * x + C * y) + (sumB[y - 1] - sumB[x]);
    if(y + 1 < n) res += (n - 1 - y) * (A * x + B * y) + (sumC[n - 1] - sumC[y]);
    return res;
}

ull calc3(int x, int y, int z) {
    if(x > y) swap(x, y);
    if(x > z) swap(x, z);
    if(y > z) swap(y, z);
    assert(x < y && y < z);
    ull res = 0;
    res += A * x + B * y + C * z;
    return res;
}

void sol() {
    for(int i = 0 ; i < n ; ++ i) {
        ull c = C * i * (1ll * i * (i - 1) / 2);
        ull b = B * i * i * (n - i - 1);
        ull a = A * i * ((1ll * n - i - 1) * (n - i - 2) / 2);
        cnt[0] += a + b + c;
    }
    for(int i = 1 ; i <= m ; ++ i) {
        int x = rel[i].x, y = rel[i].y; // x < y
        gt[x].push_back(y), lt[y].push_back(x);
        ++ deg[x], ++ deg[y];
        cnt[1] += calc1(x, y);
    }
    for(int i = 0 ; i < n ; ++ i) {
        if(lt[i].size()) sort(lt[i].begin(), lt[i].end());
        if(gt[i].size()) sort(gt[i].begin(), gt[i].end(), greater<int>());
        ull tot = lt[i].size() * gt[i].size();
        ull sumlt = 0, sumgt = 0, res = 0;
        int lttot = 0, gttot = 0;
        for(int x: lt[i]) {
            res += sumlt + lttot * B * x + lttot * C * i;
            sumlt += A * x;
            ++ lttot;
        }
        for(int y: gt[i]) {
            res += gttot * A * i + gttot * B * y + sumgt;
            sumgt += C * y;
            ++ gttot;
        }
        if(lt[i].size() && gt[i].size()) {
            res += sumlt * gt[i].size();
            res += B * i * tot;
            res += sumgt * lt[i].size();
        }
        cnt[2] += res;
    }
    for(int i = 1 ; i <= m ; ++ i) {
        int x = rel[i].x, y = rel[i].y;
        if(deg[x] < deg[y]) swap(x, y);
        if(deg[x] == deg[y] && x > y) swap(x, y);
        g[x].push_back(y);
    }
    for(int x = 0 ; x < n ; ++ x) {
        if(g[x].size()) sort(g[x].begin(), g[x].end());
        for(int y: g[x]) vis[y] = 1 + x;
        for(int y: g[x])
            for(int z: g[y])
                if(vis[z] == 1 + x)
                    cnt[3] += calc3(x, y, z);
    }
    ans = cnt[0] - cnt[1] + cnt[2] - cnt[3];
}

int main() {
    ios :: sync_with_stdio(0), cin.tie(0), cout.tie(0);
    freopen("girls.in", "r", stdin);
    freopen("girls.out", "w", stdout);
    cin >> n >> m;
    cin >> A >> B >> C;
    for(int i = 0 ; i < n ; ++ i) {
        if(i) sumA[i] += sumA[i - 1], sumB[i] += sumB[i - 1], sumC[i] += sumC[i - 1];
        sumA[i] += A * i;
        sumB[i] += B * i;
        sumC[i] += C * i;
    }
    vector<pair<int, int> > tmp;
    for(int i = 1 ; i <= m ; ++ i) {
        cin >> rel[i].x >> rel[i].y;
        assert(rel[i].x != rel[i].y);
        tmp.push_back(make_pair(min(rel[i].x, rel[i].y), max(rel[i].x, rel[i].y)));
    }
    sort(tmp.begin(), tmp.end());
    tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
    m = tmp.size();
    for(int i = 1 ; i <= m ; ++ i) rel[i].x = tmp[i - 1].first, rel[i].y = tmp[i - 1].second;
    sol();
    cout << ans << endl;
}