一些经典的容斥问题

• 在平面中给$n$个点，求这$n$个点构成的三角形/锐角三角形的个数。

求三角形的个数比较简单。首先全集是$inom{n}{3}$，然后考虑补集，补集就是三点共线的点对。所以我们可以枚举每一个点，然后为了避免算重，我们接下来只考虑标号比当前点小的点。接着就进行极角排序，这样就可以统计出当前点所在的所有直线以及直线上的点的个数。设某直线上有$m$个点，那么答案就减去$inom{m}{3}$即可。注意处理重点的情况。

求锐角三角形的个数也比较简单，只不过补集除了三点共线之外，还会有钝角三角形和直角三角形。然而我们还是可以考虑枚举每一个点$u$，只不过这里不需要只考虑标号比当前点小的点了，因为接下来的算法不会算重。然后也还是极角排序，然后按照极角序枚举另一个点$v$，这样就构成了一条线段$u-v$。然后过点$u$作线段$u-v$的垂线，那么在垂线另一边或者正好在垂线上的点都和$u,v$构成非锐角三角形或直线，统计这样的点的个数即可，利用单调性可以做到$O(n)$求解。然后每个非锐角三角形或直线会被算两次，所以最后再除以2就行了。

至于题目的话，就写个正解写个暴力拍一拍吧。反正你们这么强，分分钟就可以写完。

• 给一个环，环上有$n$个点。现在你有$m$种颜色，然后你要给每个点染一种颜色，并使得最后所有相邻的点的颜色都不相同，问有多少种染色方案。

首先考虑全集，就是$m imes (m-1)^{n-1}$。意思就是第一个点任选颜色，后面的点任选和上个点不同的颜色。听起来很靠谱，但是最后一个就可能和第一个变成一样的颜色。所以我们要减去补集，就是最后一个和第一个颜色相同的情况的种数，即$m imes (m-1)^{n-2}$。然后发现又减多了，把倒数第二个和倒数第一个颜色相同的情况也给减掉了，实际上这是不能减的，所以我们要加回来，即加上$m imes (m-1)^{n-3}$。就这样一直反复，直到最后没有后续状态了为止。所以有：

$$Ans=m imes(m-1)^{n-1}-m imes(m-1)^{n-2}+m imes(m-1)^{n-3}-m imes(m-1)^{n-4}+...+m imes(-1)^{n-1}$$

最后用等比公式求和即可简化计算。

再给一个类似的题吧。http://codeforces.com/gym/100548/attachments F题

• 给一个$n imes m$的网格，你一开始在$(1,1)$上，然后要走到$(n,m)$，每次可以往右走或者往下走一格，但是不能出界。然而在网格中有$k$个障碍点，你不能走到障碍点上，问有多少种从$(1,1)$走到$(n,m)$的走法。

首先全集就是$inom{n+m-2}{n-1}$，要走$n+m-2$步，其中有$n-1$步是往下，所以总方案数就是$inom{n+m-2}{n-1}$。做这类题目的关键因素之一就是能够很快的算出或者预处理出一个子矩阵的全集。然后我们考虑补集，我们考虑只经过了一个障碍点的路径，假设该障碍点是$(u,v)$，那么所有经过该障碍点的路径条数即为$S(u,v) imes S(n-u+1,m-v+1)$，其中$S(x,y)$表示从$(1,1)$走到$(x,y)$的放案数，即$inom{x+u-2}{x-1}$。然后将其减去。但是我们再来考虑那些经过了两个障碍点的路径，这些路径被减去了两次，所以我们要加回来。然后又要减去经过了三个障碍的，加上经过了四个障碍的......所以我们可以考虑给障碍点之间连边。$(u,v)$给$(p,q)$连边当且仅当$ule p$且$vle q$且$u eq p,v eq q$。但是在这样的图中链是很多的，所以我们可以考虑动态规划。设$Dp[i][j]$表示从$(1,1)$开始，以$j$结尾的包含了$i$个障碍点的路径条数，转移就枚举$j$的每一个后继$u$，令$Dp[i+1][u]+=Dp[i][j] imes S(x_u-x_j+1,y_u-y_j+1)$，然后$Dp[i][j]$对答案的贡献就是$Dp[i][j] imes S(n-x_j+1,m-y_j+1) imes (-1)^i$，累加贡献即可。复杂度是$O(Calc_S imes k^3)$的，其中$Calc_S$是计算$S$的时间复杂度。

给一个类似的题：http://acm.hdu.edu.cn/showproblem.php?pid=5794。

我把我的代码贴上来吧，仅供参考。

#include <map>
#include <ctime>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long LL;
#define N 100 + 5
#define Mod 110119

int Case, r, ans, Fac[Mod], Inv[Mod], Ord[N], TMP[N][N], W[N][N];
bool Ok[N], Inq[N];
LL n, m, X[N], Y[N], _X[N], _Y[N];
vector <int> To[N], Vec[N];

inline int Inc(int a, int b)
{
    return a + b - (a + b >= Mod ? Mod : 0);
}

inline bool cmp(int u, int v)
{
    return make_pair(X[u], Y[u]) < make_pair(X[v], Y[v]);
}

inline int Power(int u, int v)
{
    int res = 1;
    for (; v; v >>= 1)
    {
        if (v & 1) res = (LL) res * u % Mod;
        u = (LL) u * u % Mod;
    }
    return res;
}

inline void Prepare()
{
    Fac[0] = Inv[0] = 1;
    for (int i = 1; i < Mod; i ++)
        Fac[i] = (LL) Fac[i - 1] * i % Mod;
    Inv[Mod - 1] = Power(Fac[Mod - 1], Mod - 2);
    for (int i = Mod - 2; i; i --)
        Inv[i] = (LL) Inv[i + 1] * (i + 1) % Mod;
}

inline int C(int x, int y)
{
    if (x < y) return 0;
    return (LL) Fac[x] * Inv[y] % Mod * Inv[x - y] % Mod;
}

inline int Com(LL x, LL y)
{
    if (x < y || x < 0 || y < 0) return 0;
    if (y == 0) return 1;
    if (x < Mod && y < Mod) return C(x, y);
    return (LL) C(x % Mod, y % Mod) * Com(x / Mod, y / Mod) % Mod;
}

inline int Get(LL u, LL v)
{
    if ((u + v - 2) % 3 != 0) return 0;
    LL t = (u + v - 2) / 3;
    LL x = u - 1 - t, y = v - 1 - t;
    int res = Com(x + y, x);
    return res;
}

inline int Get_1(int u, int v)
{
    if (TMP[u][v] != -1) return TMP[u][v];
    return TMP[u][v] = Get(X[v] - X[u] + 1, Y[v] - Y[u] + 1);
}

inline void Handle()
{
    ans = Get_1(0, r + 1);
    for (int i = 1; i <= r; i ++)
    {
        if (!Ok[i]) continue ;
        Vec[1].push_back(i);
        W[1][i] = Get_1(0, i);
    }
    for (int k = 1; k <= r; k ++)
    {
        for (int i = 1; i <= r; i ++) Inq[i] = 0;
        for (int i = 0; i < Vec[k].size(); i ++)
        {
            int j = Vec[k][i];
            int tmp = (LL) W[k][j] * Get_1(j, r + 1) % Mod;
            if (k & 1) tmp = Mod - tmp;
            ans = Inc(ans, tmp);
            for (int l = 0; l < To[j].size(); l ++)
            {
                int d = To[j][l];
                if (!Ok[d]) continue ;
                if (!Inq[d]) Vec[k + 1].push_back(d), Inq[d] = 1;
                W[k + 1][d] = Inc(W[k + 1][d], (LL) W[k][j] * Get_1(j, d) % Mod);
            }
        }
    }
}

int main()
{
    Prepare();
    while (scanf("%lld%lld%d", &n, &m, &r) > 0)
    {
        X[0] = Y[0] = 1, Ok[0] = 1;
        bool ok = 1;
        for (int i = 1; i <= r; i ++)
        {
            scanf("%lld%lld", X + i, Y + i);
            if (X[i] == n && Y[i] == m) ok = 0;
            Ord[i] = i, Ok[i] = 1;
        }
        for (int i = 0; i <= r + 1; i ++)
            for (int j = 0; j <= r + 1; j ++)
                TMP[i][j] = -1, W[i][j] = 0;
        sort(Ord + 1, Ord + r + 1, cmp);
        for (int i = 1; i <= r; i ++)
            _X[i] = X[Ord[i]], _Y[i] = Y[Ord[i]];
        for (int i = 1; i <= r; i ++)
        {
            X[i] = _X[i], Y[i] = _Y[i];
            if (X[i] == X[i - 1] && Y[i] == Y[i - 1]) Ok[i] = 0;
        }
        if (n == 1 && m == 1)
        {
            printf("Case #%d: %d
", ++ Case, 1);
            continue ;
        }
        if (!ok)
        {
            printf("Case #%d: %d
", ++ Case, 0);
            continue ;
        }
        X[r + 1] = n, Y[r + 1] = m, Ok[r + 1] = 1;
        for (int i = 0; i <= r + 1; i ++)
            To[i].clear(), Vec[i].clear();
        for (int i = 1; i < r; i ++)
            for (int j = i + 1; j <= r; j ++)
                if (X[j] > X[i] && Y[j] > Y[i] && Ok[j])
                    To[i].push_back(j);
        Handle();
        printf("Case #%d: %d
", ++ Case, ans);
    }
    return 0;
}