因数（factor）

一个最基本的算数法则就是大于1的整数都能用1个或多个素数相乘的形式表示出来。当然，有多种质因子排列方案

如：

10=2×5=5×2    20=5×2×2=2×5×2=2×2×5

用f(k)表示k的质因数排列数，f(10)=2,f(20)=3

给一个n，至少有一个k满足f(k)=n的最小k

输出格式：n和k

输入：

1

2

3

105

输出：

1 2

2 6

3 12

105 720

数据范围

n，k<2^63

我们令k=∏pi^ei

  S=∑ei

f(k)=S!/(∏ei!)

解释一下：S是所有因数的个数，ei是每一种因数的个数

显然不考虑重复的情况时方案为S！

那么算上重复的会怎样？

1112是已定的

如果是算总方案显然4！，那么111会导致的重复方案是3！2导致的重复方案为1！

所以有了以上结论

那么我们有了一种方法：枚举k得到n

显然不行

那么是否可以试一下已知n，得到k？

已知对于一个指数e，如果在可行条件下，那么它显然优先给最小的质因数，这能导致k最小

搜索+剪枝实现

剪枝1：上面说的优先给小的素数，就是说ei要单调递增，因为如果ei>ej,i>j,那么显然把ei与ej

交换才能最优

剪枝2：假设你每举了t素数的指数e

就要把n除以 ((S-e+1)*...*S) /e!

如何高效算出?

原式=>S!/(e!*(S-e)!)

这不就是C(S,S-e)吗？

预处理出C，然后每一层枚举一个素数的指数，然后向下

剪枝3：最优性剪枝，当前k>ans 则退出

预处理幂不说了

但记住无论是幂，还是k，都不能超过(1<<63)-1

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 int pr[]={,,,,,,,,,,,,,,};
 long long pw[][],C[][],ans;
 long long inf;
 long long min(long long a,long long b)
 {
   if (a<b) return a;
   else return b;
 }
 void dfs(int t,long long now,long long pre,long long s,int down)
 {
   if (s>ans) return;
   if (now==)
     {
       ans=min(ans,s);
       return;
     }
   if (t>) return;
   for (int i=pre+;i<=min(pre+down,);i++)
     if (now%C[i][i-pre]==&&pw[t][i-pre]&&s<=inf/pw[t][i-pre])
       dfs(t+,now/C[i][i-pre],i,s*pw[t][i-pre],i-pre);
 }
 void ask_ans(long long k)
 {
   ans=inf;
   dfs(,k,,,);
   ans=max(ans,);
 }
 int main()
 {int i,j,k;
   freopen("factor.in","r",stdin);
   freopen("factor.out","w",stdout);
   C[][]=;
   for (i=;i<;i++)
     {
       C[i][]=C[i][i]=;
       for (j=;j<i;j++)
         C[i][j]=C[i-][j-]+C[i-][j];
     }
   for (i=;i<=;i++)
     {
       pw[i][]=;
       for (j=;j<=;j++)
     {
       if (i&&pw[i][j-]>inf/pr[i]) break;
       pw[i][j]=pw[i][j-]*pr[i];
     }
       if (i==)
     inf=pw[][]-;
     }
   while (cin>>k)
     {
       ask_ans(k);
       cout<<k<<' '<<ans<<endl;
     }
 }