从数组数组中找到所有可能解决方案的算法

Question

从字符数组中找到所有可能单词的最佳算法是什么。

这里是一个例子： 来自这个数组：[[A],[B,C,D],[E,F],[G,H]] 作为回报，我需要一个包含 12 个有序可能性的数组 [[A,B,E,G],[A,C,E,G], ... , [A,D,F,H]]

你知道如何实现这个算法吗？如果您知道它并且您提供了任何语言（C、JAVA、Javascript、...）的示例，请随时分享，因为这是我尝试找到它的一天...

这里我是如何尝试实现它的（“array”是一个char数组）：

+ (NSArray*) possibleReading:(NSMutableArray*)array {
    int nbPossibilities = 1;
    for(int i = 0; i < [array count]; i++) {
        nbPossibilities *=[[array objectAtIndex:i] count];
    }

    NSMutableArray *possArr = [[NSMutableArray alloc] initWithCapacity:nbPossibilities];
    for (int i=0; i < nbPossibilities; i++) {
        NSMutableArray *innerArray = [[NSMutableArray alloc] initWithCapacity:[array count]];
        [possArr addObject:innerArray];
    }

    for (int i=0; i< [array count]; i++) {
        //
        for(int nbPoss = 0; nbPoss < nbPossibilities; nbPoss++) {
            NSMutableArray * arr = [possArr objectAtIndex:nbPoss];
            NSNumber * num = [NSNumber numberWithInt:nbPoss % [[array objectAtIndex:i] count]];
            NSString * literal = [[array objectAtIndex:i] objectAtIndex:[num intValue]];
            [arr insertObject:literal atIndex:i];
        }

    }
    return possArr;
}

Answer 1

使用递归方法最容易做到这一点。

Java 代码

import java.util.Arrays;

public class CartesianProductCalculator {

    private char[][] result;
    private char[][] sets;
    private char[] currentSet;
    private int index;

    public char[][] calculateProduct(char[][] sets) {
        index = 0;
        // calculate size of result
        int resultSize = 1;
        this.sets = sets;
        for (char[] set : sets) {
            resultSize *= set.length;
        }
        result = new char[resultSize][];
        currentSet = new char[sets.length];
        calculateProduct(sets.length-1);
        return result;
    }

    // fills result from right to left
    public void calculateProduct(int setIndex) {
        if (setIndex >= 0) {
            for (char c : sets[setIndex]) {
                currentSet[setIndex] = c;
                calculateProduct(setIndex-1);
            }
        } else {
            result[index++] = Arrays.copyOf(currentSet, currentSet.length);
        }
    }

    public static void main(String[] args) {
        char[][] input = {{'A'},{'B','C','D'},{'E','F'},{'G','H'}};
        CartesianProductCalculator productCalculator = new CartesianProductCalculator();
        System.out.println(Arrays.deepToString(productCalculator.calculateProduct(input)));
    }
    
}

Answer 2

Objectiv-C

   + (NSArray *) cartesianProductOfArrays(NSArray *arrays) {
        int arraysCount = arrays.count;
        unsigned long resultSize = 1;
        for (NSArray *array in arrays)
            resultSize *= array.count;
        NSMutableArray *product = [NSMutableArray arrayWithCapacity:resultSize];
        for (unsigned long i = 0; i < resultSize; ++i) {
            NSMutableArray *cross = [NSMutableArray arrayWithCapacity:arraysCount];
            [product addObject:cross];
            unsigned long n = i;
            for (NSArray *array in arrays) {
                [cross addObject:[array objectAtIndex:n % array.count]];
                n /= array.count;
            }
        }
        return product;
    }

Answer 3

C

#include <stdio.h>
#include <string.h>

void print(int size, char *array[size], int indexs[size]){
    char result[size+1];
    int i;
    for(i = 0; i < size; ++i)
        result[i] = array[i][indexs[i]];
    result[size] = 0;
    puts(result);
}

int countUp(int size, int indexs[size], int lens[size]){
    int i = size -1;
    while(i >= 0){
        indexs[i] += 1;// count up
        if(indexs[i] == lens[i])
            indexs[i--] = 0;
        else
            break;
    }
    return i >= 0;
}

void find_all(int size, char *array[size]){
    int lens[size];
    int indexs[size];
    int i;

    for(i = 0; i < size; ++i){//initialize
        lens[i] = strlen(array[i]);
        indexs[i] = 0;
    }

    do{
        print(size, array, indexs);
    }while(countUp(size, indexs, lens));
}

int main(void){
    char *array[] = { "A", "BCD", "EF", "GH" };
    int size = sizeof(array)/sizeof(*array);

    find_all(size, array);
    return 0;
}

Answer 4

如果您可以在执行方法之前删除内部数组对象中的重复条目，那么您将不会在结果数组中得到重复的单词。

- (NSArray*) possibleReading:(NSMutableArray*)array {
    int nbPossibilities = 1;
    for(int i = 0; i < [array count]; i++) 
     {


        NSArray *cleanedArray = [[NSSet setWithArray:[array objectAtIndex:i]] allObjects];
        [array replaceObjectAtIndex:i withObject:cleanedArray];
         nbPossibilities *=[[array objectAtIndex:i] count];
    }

    NSMutableArray *possArr = [[NSMutableArray alloc] initWithCapacity:nbPossibilities];
    for (int i=0; i < nbPossibilities; i++) {
        NSMutableArray *innerArray = [[NSMutableArray alloc] initWithCapacity:[array count]];
        [possArr addObject:innerArray];
    }

    for (int i=0; i< [array count]; i++) {
        //
        for(int nbPoss = 0; nbPoss < nbPossibilities; nbPoss++) {
            NSMutableArray * arr = [possArr objectAtIndex:nbPoss];
            NSNumber * num = [NSNumber numberWithInt:nbPoss % [[array objectAtIndex:i] count]];
            NSString * literal = [[array objectAtIndex:i] objectAtIndex:[num intValue]];
            [arr insertObject:literal atIndex:i];
        }

    }
    return possArr;
}