Algorithm 一个指数递归函数的分析

我试图计算以下问题的复杂性 指数递归函数

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); 
}

void RecuriveCall（int A[]，int ASize，short int B[]，int BSize，
int y，短int级）{
intc[OBJECTSIZE]；
短int D[属性化]；
int CSize，DSize；
打印结果（A、ASize、B、BSize）；
对于（int j=y；j我已尝试将以下重复关系调整到代码中，请参见以下步骤：



其中
n=MAXATTRIBUTES
（常数）和
m=ASize
您想到了什么？它在哪里失败/工作？您能提供isMember和isNotComputed的源代码吗？我们可以假设函数1和函数2是O（1），但前两个函数的结果对于理解整体复杂度至关重要。感谢Alejandro。如果忽略isMember（）和isNotComputed（）方法，代码的复杂度为O（2^N）。但是在实践中，此算法的运行速度为O（N^2）.谢谢Juan。我已经包含了其他函数的代码。感谢您的输入。顺便说一下，算法计算形式概念（形式概念分析）.Thank.n=MAXATTRIBUTES；我已经更新了代码，将其用作全局变量，这不是一个好的做法。非常感谢。我将介绍您的解决方案。嗨，Ennnahdi，请快速检查。即使我们忽略函数1（）和函数2（），时间复杂度也不会是O（2^n）或O（n！）。请参见[link嗨，不应该，TRecCall（y+1）在解决方案的第一行，它应该在sigma内。你是对的，它应该在sigma内，但它应该乘以一些概率函数，因为它是在两个条件下执行的。对于前面的问题，我需要重新计算以断言它是O（2^N）或O（N！）。