Question

我正在尝试计算以下内容的复杂性指数递归函数。

isMember（）和isNotComputed（）函数会减少数量递归调用。

此代码的输出是一组A []，B []，它们打印在递归函数调用的初始部分。

对于为此开发递归关系的任何意见表示感谢问题会导致对该计划的分析。

如果没有函数isMember（），则isNotComputed（）此代码的复杂度为O（2 ^ N）。根据经验（具有上述两个函数），该代码具有O（| N ^ 2 || L |）的复杂度。其中L是所做的递归调用的数量，即生成的结果。

我正在尝试尽可能准确地计算此代码的复杂性，以便我可以将其效率与一组本质上相似的其他算法进行比较。

void RecuriveCall(int A[], int ASize, short int B[], int BSize, 
              int y, short int level) { 
    int C[OBJECTSIZE]; 
    short int D[ATTRIBUTESIZE]; 
    int CSize, DSize; 
    PrintResult( A,ASize, B, BSize);                                                                         
    for (int j=y; j<n; j++) {                                                  
        if (! isMember(j, B, BSize)) {                                      
            function1(C,CSize,A,ASize,j);                             
            function2(D,DSize,C, CSize);                                 
            if (isNotComputed(B, BSize, D, DSize, j)) {                                                                                     
                RecursiveCall(C, CSize,D, DSize, j+1, level+1); 
            }      

        } 
    } 

}    

// Complexity - O(log N) - Binary Search
bool isMember(int j,short int B[], int BSize) { 
    int first, mid, last; 
    first = 0; 
    last = BSize-1; 

    if (B[first] == j || B[last] == j) { 
        return true; 
    } 

    mid = (first+last)/2; 
    while (first <= last) { 
        if (j == B[mid]) { 
            return true; 
        } 
        else if (j < B[mid])  
            last = mid-1; 
        else
            first = mid+1; 
        mid = (first+last)/2; 
    } 
    return false; 
}
// complexity - O(N)
bool isNotComputed(short int B[], int BSize, short int D[], int DSize,int j) { 
    if (j==0) { 
        return true; 
    } 

    int r = 0; 
    while (r<BSize && B[r]<j && r<DSize && D[r]<j) { 
        if (B[r] != D[r]) { 
            return false; 
        } 
        r=r+1; 
    } 
    // Now we can check if either B[] or D[] has extra elements which are < j 
    if (r<BSize && r < DSize && B[r]>=j && D[r] >=j) {// we know it is okay 
        return true; 
    } 
    if (r==BSize && r==DSize) {  
        return true; 
    } 
    if (r==BSize && r<DSize && D[r] >=j) {  
        return true; 
    } 
    if (r==DSize && r<BSize && B[r] >=j) { 
        return true; 
    } 
    return false; 
} 


// Complexity - O(N)
void function1(int C[],int &CSize,int A[] ,int ASize,int j) { 
    int tsize = 0; 
    for (int r=0;r<ASize;r++) 
        if (I[A[r]][j]==1) 
            C[tsize++] = A[r]; 
    CSize = tsize; 
} 

// Complexity - O(|N||G|) - G - number of objects
void function2(short int B[], int &BSize,int A[], int ASize) { 
   int i,j; 
   int c=0; 
    // Iterate through all attributes 
   for (j = 0; j < MAXATTRIBUTES; ++j) { 
      // Iterate through all objects 
      for (i = 0; i < ASize; ++i)  
         if (!I[A[i]][j]) 
            break; 
      if (i == ASize)  
         B[c++] = j; 
   } 
   BSize = c; 
}

void main() {
   n = MAXATTRIBUTES;
   for (int r=0; r<MAXOBJECTS; r++) 
       A[r] = r; 
   ASize = MAXOBJECTS; 
   function2(B, BSize, A, ASize); 

   RecursiveCall(A, ASize,B, BSize, 0, 0); 
}

“mohamed ennahdi el idrissi”提出的答案解决了如何开发递归关系的问题。

如何将函数isMember（）和isNotComputed（）函数合并到此中。实质上，这些会显着减少递归调用的次数。有没有办法引入概率函数来表示它们？即P（f（n））xRecCall（n-1）。我已经看到一些算法的复杂性已被计算，例如为O（N ^ 2.48）。你是如何得到这样的价值观的？

Answer 1

我尝试将以下重复关系调整为您的代码，请参阅以下步骤：

enter image description here

n = MAXATTRIBUTES（常数）和m = ASize。

分析指数递归函数

1 个答案: