【数论---组合数】组合数问题 & Irrelevant Elements

Problem 1: Contest2890 - 2021个人训练赛第38场 L：组合数问题I

评测传送门


题目大意:
计算${\sum }_{i=0}^n{\sum }_{j=0}^{min(i,m)}(C_i^j\%k==0)$.

解题思路：
这个题的数据范围不是很大，因此可以借用杨辉三角的纵向递推关系来求组合数。对于能够被 $k$ 整除的位置，我们用另外一个二维数组来进行标记这个位置所产生的贡献，最终答案根据标记数组来求一个二维前缀和即可。

二维前缀和是求一个矩形内所有元素的和，对于本题来说，这个矩形的左下角是有效区域（杨辉三角），根据题意标记出某些位置对答案产生的贡献，右上角是无效区域不会产生贡献，全置 $0$ 即可.

AC Coding:

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 2010;
int f[N][N], s[N][N], a[N][N];
void init(int k) {
    f[0][0] = 1;
    f[1][0] = f[1][1] = 1;
    for (int i = 2;i < N;i++) {
        for (int j = 0;j <= i;j++) {
            if (i == 0 || i == j) f[i][j] = 1;
            else f[i][j] = (f[i - 1][j - 1] + f[i - 1][j]) % k;
            if (f[i][j] == 0) a[i][j] = 1;
        }
    }
    for (int i = 1;i < N;i++) {
        for (int j = 1;j < N;j++) {
            s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
        }
    }
}
int main() {
    int t, k;cin >> t >> k;
    init(k);
    /*for (int i = 0;i < 10;i++) {
        for (int j = 0;j <= i;j++) {
            cout << f[i][j] << " ";
        }
        cout << endl;
    }*/
    while (t--) {
        int n, m; cin >> n >> m;
        cout << s[n][m] << endl;
    }
    return 0;
}

Problem 2: Irrelevant Elements

利用杨辉三角的纵向递推式解决了上面那个题之后，欢佬给我引荐了下面这个题，和上面那个题大同小异，都是求组合数是否能被某个数整除，数据范范围上来了，杨辉三角的做法指定时卡没了。
评测传送门

题目大意：
给出 $n$ 和 $m$ , 求有多少个 $i(0\le i\le n)$ 满足$C_{n-1}^{i-1}\%m=0$。输出总的数量和满足关系式的所有的 $i$ 的值。

解题思路：
首先来看一些关于组合数的恒等式。
$$C_n^k=\frac{n!}{k!(n-k)!}$$
$$C_n^{k-1}=\frac{n!}{(k-1)!(n-k+1)!}$$
$$C_n^k=\frac{n-k+1}{k}{C}_n^{k-1}$$
没错，根据第三个式子，我们发现了组合数的横向递推式（来源于紫书）。
怎么判断是否能被 $m$ 整除呐，这个方法也很是巧妙，一般的想法是将所求组合数唯一分解，将 $m$ 也唯一分解，然后判断是否 $m$ 中的所有的质因子的指数都小于等于组合数唯一分解后所对应的质因子的指数。（没错，这是我一开始的想法）

想法是没错，但是时间复杂度堪忧啊，唯一分解一个组合数的复杂度与唯一分解$n!$ 的时间复杂度雷同,没记错的话应该是$O(nlogn)$，要分解$n$个，总的时间复杂度$O(n^{2}logn)$。

正解思路，根据上述横向递推式来分解，首先对于m中不存在的质因子，直接不用考虑，只考虑与 $m$ 中质因子相关的，根据横向递推式，每次只需分解$(n-k+1)$ 和 $k$ 即可，从前往后处理，在上一个分解后的结果之上进行递推。

AC Coding:

#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
#define x first
#define y second
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 100010;
PII foc[N];
int f[N];
int n, mod, cnt;
void get_prime_foctor(int p) {
	cnt = 0;
	for (int i = 2;i <= p / i;i++) {
		if (p % i == 0) {
			int s = 0;
			while (p % i == 0) {
				p /= i;
				s++;
			}
			foc[++cnt] = { i,s };
		}
	}
	if (p > 1) foc[++cnt] = { p,1 };
}
bool check(int n, int k) //判断C(n,m)是否整除mod
{
	//C(n,k) = (n - k + 1) / k * C(n,k-1)
	int X = n - k + 1;
	int Y = k;
	for (int i = 1;i <= cnt;i++) {
		int p = foc[i].x;
		while (X % p == 0) {
			X /= p;
			f[i]++;
		}
		while (Y % p == 0) {
			Y /= p;
			f[i]--;
		}
	}
	/*这里可能会发出疑问，为啥只对X和Y分解就可以了呐？
	因为上一个的质因子分解的结果已经被我们存储在f数组中了，
	并没有对其进行清空，而是在它的基础之上再次分解X和Y，并再计入f数组中
	来得到当前组合数的分解结果。
   */
	for (int i = 1;i <= cnt;i++) {
		if (f[i] < foc[i].y) return false;
	}
	return true;
}
int main() {
	bool flag = false;
	while (~scanf("%d%d", &n, &mod)) {
		get_prime_foctor(mod);
		memset(f, 0, sizeof f);
		vector<int> res;
		for (int i = 1;i < n;i++) {
			if (check(n - 1, i)) {
				res.push_back(i + 1);
			}
		}
		printf("%d\n", res.size());
		for (int i = 0;i < res.size();i++) {
			if (i == 0) printf("%d", res[i]);
			else printf(" %d", res[i]);
		}
		printf("\n");
	}
	return 0;
}

参考文献