Pave the Parallelepiped(有重复组合公式+状态压缩)

最新推荐文章于 2020-06-09 16:22:08 发布

Guuuuuu老师儿

最新推荐文章于 2020-06-09 16:22:08 发布

阅读量961

点赞数 1

CC 4.0 BY-SA版权

分类专栏： # 组合数学

本文链接：https://blog.youkuaiyun.com/codeswarrior/article/details/81146331

组合数学专栏收录该内容

39 篇文章

订阅专栏

本文探讨了一道关于将长方体分割成多个小长方体的组合数学问题，通过巧妙的状态压缩与容斥原理，实现了高效的算法解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Pave the Parallelepiped

You are given a rectangular parallelepiped with sides of positive integer lengths A, B and C

Find the number of different groups of three integers (a
, b, c) such that 1≤a≤b≤c and parallelepiped A×B×C can be paved with parallelepipeds a×b×c

. Note, that all small parallelepipeds have to be rotated in the same direction.

For example, parallelepiped 1×5×6
can be divided into parallelepipeds 1×3×5, but can not be divided into parallelepipeds 1×2×3

Input

The first line contains a single integer t

(1≤t≤105

) — the number of test cases.

Each of the next t
lines contains three integers A, B and C (1≤A,B,C≤105

) — the sizes of the parallelepiped.

Output

For each test case, print the number of different groups of three points that satisfy all given conditions.

Example
Input

4
1 1 1
1 6 1
2 2 2
100 100 100

Output

1
4
4
165

Note

In the first test case, rectangular parallelepiped (1,1,1)

can be only divided into rectangular parallelepiped with sizes (1,1,1)

In the second test case, rectangular parallelepiped (1,6,1)
can be divided into rectangular parallelepipeds with sizes (1,1,1), (1,1,2), (1,1,3) and (1,1,6)

In the third test case, rectangular parallelepiped (2,2,2)
can be divided into rectangular parallelepipeds with sizes (1,1,1), (1,1,2), (1,2,2) and (2,2,2).

题意：

有一个 $A \times B \times C$ 的长方体，将其分成 $a\times b \times c$ 的小正方体，其中 $a \le b \le c$ 问这样的abc小正方体能有多少种？

分析：

首先我们能够想到的就是abc至少一个是A的因子，一个是B的因子，一个是C的因子。

如果直接用组合数学进行推公式的话，需要考虑的情况太多，细节太多，一般人绝对考虑不全。

我们整体考虑对于a，b，c每个数无非有7中情况，所以我们考虑用三位二进制来表示状态

001 是A的因数
010 是B的因数
011 是A的因数也是B的因数即是gcd（A，B）的因数
100 是C的因数
101 是A的因数也是C的因数即是gcd（A，C）的因数
110 是B的因数也是C的因数即是gcd（B，C）的因数
111 是A的因数也是B的因数也是C的因数即是gcd（A，B，C）的因数

根据题意我们完全可以预处理处最大范围内每个数的因子个数，然后每个样例对于所给的A，B，C
求出gcd(A,B),gcd(A,C),gcd(B,C);
我们便可以利用容斥定理求出7种状态的因子个数cnt[i](i = 1,2,…7)

这样对于a，b，c我们只需要枚举每个数的状态（三重循环），并判断保证三个数至少有一个是A的因子B的因子C的因子，这样我们就得到了满足条件的a，b，c的个数。

1.如果说a，b，c都是不同的状态，那么我们就得到三种数量，从每种数量中选择1个，利用组合数很好求

2.但是如果有两个数或者三个数相同的状态，这就要求我们从一定数量中选择有重复个元素举个例子
如果ab状态相同，都是cnt[s]，那么我们应该从cnt[s]中选两个，并且可以重复即a选了k，b也选了k
这就需用到有重复的组合公式：
如果从n个元素中选择r个有重复元素，其公式为：

$C_{n+r-1}^{r}$

此链接为证明过程

这样对于枚举的一种abc状态，各个数的种类数相乘即可，最后每种abc状态个数相加即为最终答案

是个组合数学好题

code：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5+10;
ll C(int n,int m){//求组合数
    ll ans = 1;
    for(int i = 1; i <= m; i++){
        ans = ans * (n-i+1) / i;
    }
    return ans;
}
bool check(int a,int b,int c){//保证可以构成大正方形
    if((a & 1) && (b & 2) && (c & 4))
        return true;
    if((a & 1) && (c & 2) && (b & 4))
        return true;
    if((b & 1) && (a & 2) && (c & 4))
        return true;
    if((b & 1) && (c & 2) && (a & 4))
        return true;
    if((c & 1) && (a & 2) && (b & 4))
        return true;
    if((c & 1) && (b & 2) && (a & 4))
        return true;
    return false;
}
int gcd(int a,int b){
    if(b == 0)
        return a;
    return gcd(b,a%b);
}
int cnt[10],use[10];
int fac[maxn];
int main(){
    //预处理因子个数
    for(int i = 1; i < maxn; i++){
        for(int j = i; j < maxn; j += i){
            fac[j]++;
        }
    }
    int t,x,y,z;
    ll ans;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d",&x,&y,&z);
        int xy = gcd(x,y);
        int yz = gcd(y,z);
        int xz = gcd(x,z);
        int xyz = gcd(xy,z);
        //容斥计算出每种状态的因子个数
        cnt[7] = fac[xyz];//111
        cnt[6] = fac[yz] - fac[xyz];//110
        cnt[5] = fac[xz] - fac[xyz];//101
        cnt[4] = fac[z] - fac[xz] - fac[yz] + fac[xyz];//100
        cnt[3] = fac[xy] - fac[xyz];//011
        cnt[2] = fac[y] - fac[xy] - fac[yz] + fac[xyz];//010
        cnt[1] = fac[x] - fac[xy] - fac[xz] + fac[xyz];//001
        ans = 0;
        for(int a = 1; a < 8; a++){
            for(int b = a; b < 8; b++){
                for(int c = b; c < 8; c++){
                    if(check(a,b,c)){
                        memset(use,0,sizeof(use));
                        use[a]++;
                        use[b]++;
                        use[c]++;//标记某种状态出现次数
                        ll tmp = 1;
                        for(int i = 1; i < 8; i++){//有使用重复组合数公式
                            if(use[i])
                                tmp *= C(cnt[i]+use[i]-1,use[i]);
                        }
                        if(tmp > 0)
                            ans += tmp;
                    }
                }
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}