POJ-3421 X-factor Chains---求因子+递推 或 素因子+组合数学

题目链接：

https://vjudge.net/problem/POJ-3421

题目大意：

给你一个数X，将X分解成1~X的因子数列，前一个数可以整数后一个数，求满足条件的最大链长以及有多少条这样长的链。

思路一：

自己的解答：

首先求出所有的因子，排序，然后定义一个length数组和tot数组，length[i]表示从第i个因子到最后一个因子的最大链长，tot[i]表示第i个因子到最后一个因子的最大链长的种类，要求length[0]和tot[0]

已知length[last] = 0，tot[last] = 1（即最后一个因子的链长记为0，这里记为0的话，最后就不用减一，因为题目中第一个因子1不计入链长，数目记为1）

然后就是从后往前的递推式：可以看个例子：

n = 100

下标　　0　　1　　2　　3　　4　　5　　6　　 7　　8

因子　　1　　2　　4　　5　　10　 20　  25　  50　 100

length　 4       3　　2　　3　　2　　1　　2　　1　　0

因子50，100可以整除50，那么length[(50)] = length[(100)] + 1 = 1

因子25，50可以整除25，那么length[(25)] = length[(50)] + 1 = 2

同理可求出上述的length数组

递推式就是length[i] = length[j] + 1(其中下标为j的因子是最小的可以整除下标为i的因子)

然后就可以推出tot数组

tot数组就相当于length从后往前有多少个0 1 2 3 4的序列

n = 100

下标　　0　　1　　2　　3　　4　　5　　6　　 7　　8

因子　　1　　2　　4　　5　　10　 20　  25　  50　 100

length　 4       　　　　　　　　　　　　　　

tot      　 6       3　　1　　3　　2　　1　　1　　1　　1

1、对于因子50的length=1，因子100的length=0，且100整除50，所以tot[(50)]=tot[(100)]=1 相当于从50开始到最后只有一条路，就是50，100

2、对于因子25的length=2，因子50的length=1，且50整除25，所以tot[(25)] = tot[(50)] = 1 相当于从25开始到最后只有一条路，就是25，50，100‘

3、对于因子20的length=1，因子100的length=0，且100整除20，所以tot[(20)] = tot[(100)] = 1 相当于从20开始只有一条路，就是20，100

4、对于因子10的length=2，因子20和50的length=1，且20和50均整除10，所以tot[(10)]=tot[(50)]+tot[(20)]=2 相当于从10开始有两条路，是10，20，100或者10，50，100

5、对于因子5的length=3，因子10和25的length=2，且10和25均整除5，所以tot[(5)]=tot[(10)]+tot[(25)]=3 相当于从5开始有三条路，是5，10，20，100或者5，10，50，100或者5，25，50，100

6、对于因子4的length=2，因子20和50的length=1，且20整除4，50不整除4，所以tot[(4)]=tot[(20)]=1 相当于从4开始有一条路，是4，20，100

7、对于因子2的length=3，因子4和10和25的length=1，且4和10整除2，25不整除2，所以tot[(2)]=tot[(4)]+tot[(10)]=3 相当于从2开始有三条路，是2，4，20，100或者2，10，20，100或者2，10，50，100

8、对于因子1的length=4，因子2和5的length=3，且2和5均整除1，所以tot[(1)]=tot[(2)]+tot[(5)]=6 相当于从1开始有六条路，是1，2，10，20，100或者1，2，10，50，100或者1，2，4，20，100或者1，5，10，20，100或者1，5，10，50，100或者1，5，25，50，100

递推式：tot[i] = sum(tot[j]) 其中第j个因子的length=第i个因子的length-1，并且第j个因子整除第i个因子

上述递推式文字说明比较繁琐，但是理解之后就特别简单，抓紧题目的意思，后一个因子整除前一个因子，然后递推式就可以想出来了。

 #include<iostream>
 #include<vector>
 #include<queue>
 #include<algorithm>
 #include<cstring>
 #include<cstdio>
 #include<set>
 #include<map>
 #include<cmath>
 using namespace std;
 typedef pair<int, int> Pair;
 typedef long long ll;
 const int INF = 0x3f3f3f3f;
 int T, n, m;
 int length[], tot[];
 vector<int> divisor(int n)
 {
     vector<int>res;
     for(int i = ; i * i <= n; i++)
     {
         if(n % i == )
         {
             res.push_back(i);
             if(i != n / i)res.push_back(n / i);
         }
     }
     return res;
 }
 int main()
 {
     while(cin >> n)
     {
         vector<int>a = divisor(n);
         sort(a.begin(), a.end());
         memset(length, , sizeof(length));
         memset(tot, , sizeof(tot));
         int m = a.size();
         length[m - ] = ;
         for(int i = m - ; i >= ; i--)
         {
             for(int j = i + ; j < a.size(); j++)
             {
                 if(a[j] % a[i] == )
                 {
                     length[i] = length[j] + ;
                     break;
                 }
             }
         }
         tot[m - ] = ;
         for(int i = m - ; i >= ; i--)
         {
             for(int j = i + ; j < m; j++)
             {
                 if(length[j] +  == length[i])
                 {
                     if(a[j] % a[i] == )
                         tot[i] += tot[j];
                 }
             }
         }/*
         for(int i = 0; i < m; i++)
         {
             cout<<a[i]<<" "<<length[i]<<" "<<tot[i]<<endl;
         }*/
         cout<<length[]<<" "<<tot[]<<endl;
     }
 }

思路二：

网上常规方法，直接求出所有素因子，然后素因子的数目就是链长，不难理解，每次递增的时候，前一个因子乘上一个素因子，直到所有素因子乘完，就到达n了

具体的数目就是这些素因子的排列组合的数目，比如100=2*2*5*5，素因子4个，排列组合次数为4！/(2!*2!) = 6，就是简单的组合数学

代码随便在网上找就行了，这里就不赘述了