题目很直白，方法就是暴力即可。

虽然说数据范围显得很大，但是在长整型范围内，一个数字的素因子数量最多不超64，而如果是不相同的素因子，虽然没有计算过，但是如果是12个不同的素因子应该会超过数据范围了。

所以果断采用找出所有素因子，再DFS做法。然而超时了.................

剪枝很容易处理，我们知道DFS算法是按顺序选择元素的，例如 2 2 3 3 3 序列，如果我们选择第一个2作为第一个元素，肯定无法形成序列，那么递归回去时下一次递归会选取第二个2作为首元，这种行为显然是没必要的。

#include <iostream>
using namespace std;
long long n,a[142]= {0},b[142]= {0},v[142],cnt=0,ok=1;
void dfs(long long  step,long long  pre)
{
    if(step==cnt+1)
    {
        cout<<cnt<<endl;
        for(int i=1; i<=cnt; i++)
            cout<<b[i]<<' ';
        ok=0;
        return ;
    }
    for(int i=1; i<=cnt&&ok==1; i++)
    {
        if(a[i-1]==a[i]&&v[i-1]==0&&v[i]==0)/**< 加上这句就不超时了，相同的素因子没必要重复递归 */
            continue;/**< 这句话的意思就是左侧和a[i]相同的数字你没有选取，那么显然a[i]也不能选取 */
        if(v[i]==0&&a[i]!=pre)
        {
            b[step]=a[i];
            v[i]=1;
            dfs(step+1,a[i]);
            v[i]=0;
        }
    }
}
int main()
{
    long long i;
    cin>>n;
    if(n==1)
    {
        cout<<-1;
        return 0;
    }
    while(n!=1) /**< 找出所有素因子，送入数组a，注意数组a一定是有序的 */
    {
        for(i=2; i*i<=n; i++)
            if(n%i==0)
                break;
        if(i*i>n)
        {
            a[++cnt]=n;
            n=1;
        }
        else
            a[++cnt]=i,n=n/i;
    }
    int len=1,maxs=0;
    for(i=2;i<=n;i++)
    {
        if(a[i]==a[i-1])
            len++;
        else
            len=1;
        maxs=max(len,maxs);
    }
    dfs(1,0);
    if(ok==1)
        cout<<-1;
    return 0;
}