查找阵列组合以使用最少量的阵列覆盖所有元素

Question

您好我是新手学习C并且一直试图解决各种问题。我对问题的最新尝试已经解决了一半，我最后一步需要知道的是这个问题。如果有这样的各种数组：

int A[4] = {1,0,1,0};
int B[4] = {1,0,0,1};
int C[4] = {0,1,1,0};
int D[4] = {0,1,0,1};

所有阵列的长度都相同＆＃39; L＆＃39;我需要弄清楚使用组合最少的数组的组合（相同位置的所有元素都添加到最初用零填充的相等长度的数组），将导致一个长度为＃的数组39，L＆＃39;其中没有一个0。

对于上面的例子，它将是A＆amp; D，或B＆amp;因此，答案将是两个数组。

它不必填充1，它可以是2或3或其他。只需要没有零。由于我们只搜索最小数量，因此可能有多种组合，但只有一种答案。 L小于10.尽管数组的数量从1到500不等。

我尝试过使用在线学习的图算法，但这个问题让我感到难过。

Answer 1

我使用 Divide＆amp;征服方法 <强>逻辑
首先，考虑数组data的集合，我们希望从中找到最小的数组，其组合只有1的数组。

我们可以一个接一个地从集合中获取所有数组。从剩余的阵列中找到最小的组，以便组和阵列中的阵列组合。当前数组满足条件。 ＆安培;最小的组合（阵列组+当前阵列）是我们的解决方案。

我们可以简单地给出问题的递归定义。

的溶液

#include<stdio.h>
#define L 4 //length of the array
#define N 4 //number of arrays
int best[N]; //array to keep track of best combination.
int nbest=N; //number of best arrays in best combination.
int D[N][L]={{1,0,1,0},{1,0,0,1},{0,1,1,0},{0,1,0,1}}; //data
int func(int track[],int ar[],int d); //get best combination
int * copy(int *a,int len); //copy contant of a to b.
int * combine(int a[],int b[],int len);
int main()
{
    int i,j;
    int empty[L]={0,0,0,0};//initial combination
    int init[N]={-1,-1,-1,-1};//initial track.
    // initialize 'best' array.
    for(i=0;i<N;i++)
        best[i]=-1;
    // initial function call
    func(init,empty,0);
    // print the result.
    printf("best combination..\n");
    for(i=0;i<nbest;i++){
        for(j=0;j<L;j++)
            printf("%d, ",D[best[i]][j]);
        printf("\n");
    }
    return 0;
}

/*
    * this is recursive function work on data array 'D'.
    * array 'track' is used to keep track of the arrays of current combination.
    * array 'ar' is indicate the current combination.
    * int 'd' indicate the number of arrays in current combination.
*/
int func(int track[],int ar[],int d){
    int i,j,*t,*tr;
    if(d>=N) //check if there are arrays remain to combine.
        return 0;   
    if(check(ar,L)){ //check if the combination is valid.
        if(nbest>d){ //check if the current solution is better then the best.
            nbest=d;
            for(i=0;i<d;i++)
                best[i]=track[i];
        }
        return 1;
    }
    tr=copy(track,N); //make local copy of track.
    for(i=0;i<N;i++){ // make combination with all remaining arrays.
        if(isin(tr,i)) // check if current array is already in combination.
            continue;
        t=copy(ar,L); //make local copy of current combination.
        tr[d]=i; // update track array to track current array.
        t=combine(t,D[i],L); // combine the array with current combination.
        if(func(tr,t,d+1)){ // recursive call, brake the loop if the current combination is valid.
            break;
        }
    }
    return 0;
}

int * combine(int a[],int b[],int len){ // return combination of array 'a' & 'b'.
    int *c=(int *)calloc(len,sizeof(int));
    int i;
    for(i=0;i<len;i++){
        c[i]=a[i]||b[i];
    }
    return c;
}

int * copy(int *a,int len){ // this function return copy of array 'a' of length 'len'
    int i;
    int *t=(int *)calloc(len,sizeof(int));
    for(i=0;i<len;i++)
        t[i]=a[i];
    return t;
}

int check(int a[],int len){ // check if the array is valid combination. i.e. all elememnts are 1.
    int i;
    for(i=0;i<len;i++)
        if(a[i]!=1)
            return 0;
    return 1;
}

int isin(int *ar,int index){ // return 1 if int 'index' is exist in array 'ar'.
    int i;
    for(i=0;i<N;i++)
        if(ar[i]==index)
            return 1;
    return 0;
}

这里我使用了数组best来跟踪我们在实例中找到的最佳解决方案。