823. 带因子的二叉树-快速排序+哈希表 c语言解法

823. 带因子的二叉树-快速排序+哈希表

给出一个含有不重复整数元素的数组 arr ，每个整数 arr[i] 均大于 1。

用这些整数来构建二叉树，每个整数可以使用任意次数。其中：每个非叶结点的值应等于它的两个子结点的值的乘积。

满足条件的二叉树一共有多少个？答案可能很大，返回 对 109 + 7 取余 的结果。

示例 1:

输入: arr = [2, 4]
输出: 3
解释: 可以得到这些二叉树: [2], [4], [4, 2, 2]

示例 2:

输入: arr = [2, 4, 5, 10]
输出: 7
解释: 可以得到这些二叉树: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].

解题代码如下，感兴趣可以学习一下，这题目前，c语言leecode还没有题解：

#define size 134

struct hash{
    struct hash *next;
    int index;
    int val;

};
void add_hash(struct hash *h,int val,int index){
    struct hash *p=(struct hash *)malloc(sizeof(struct hash ));
    p->val=val;
    p->index=index;
    p->next=h->next;
    h->next=p;
}


int  find_add(struct hash *h,int val){
    struct hash *p=h->next;
  while(p){
    
      if(p->val==val){
          return p->index;
      }
      p=p->next;
  }
  return -1;
}


void quick_sort(int *a,int low,int high){
    int l=low,h=high;
    if(low<high){
        int p=a[low];
        while(low<high){
            while(low<high&&a[high]>=p){
                high--;

            }
            a[low]=a[high];
            while(low<high&&a[low]<=p){
                low++;
            }
            a[high]=a[low];
        }
        a[low]=p;
        quick_sort(a,l,low-1);
        quick_sort(a,low+1,h);

    }
}



int cmp(const void* a, const void* b)
 {
     return *(int*)a - *(int*)b;
 }

int numFactoredBinaryTrees(int* arr, int arrSize){
   
    qsort(arr, arrSize, sizeof(int), cmp);

    int re=0;
    long long dp[arrSize];
    dp[0]=1;

    struct hash *h=(struct hash *)malloc(sizeof(struct hash)*size);
    for(int i=0;i<size;i++){
        (h+i)->next=NULL;
    }
    for(int i=0;i<arrSize;i++){
        add_hash(h+arr[i]%size,arr[i],i);
       
       
    }
   re=1;

    for(int i=1;i<arrSize;i++){
        dp[i]=1;
        int z=i;
        for(int j=0;j<z;j++){
              if(arr[j]>arr[i]/2){
                    break;
                }

            long long p=(long long)arr[j]*arr[j];
            
            if(arr[i]%arr[j]==0&&arr[i]==p){
                dp[i]=dp[i]+dp[j]*dp[j];

            }
            else if(arr[i]%arr[j]==0&&arr[i]!=p){
               
                int p=arr[i]/arr[j];
              
                int index=find_add(h+p%size,p);
                if(index!=-1){
                    

                    dp[i]=dp[i]+dp[j]*dp[index]*2;
                    z=index;
                }
                 
              
                
            }
            
        }
        re=(re+dp[i])%1000000007;
    
      
    }


    return re%1000000007;
    



}