Question

我正在处理一个组件并且有点困难，需要一些关于如何继续的帮助。我的问题如下：

我有2个对象数组。让我们说阵列的人。 person对象具有person id，parentId和其他字段作为属性。阵列1仅有男性，阵列2仅有女性。

因此，样本看起来像这样：

数组1：
personId sex parentId
11 M 1
22 M 2
33 M 3

数组2：
personId sex parentId
44 F 1
55 F 2
66 F 3

阵列3
personId sex parentId
44 F 4
55 F 4
66 F 5

我需要检查一下，看看我是否可以将所有男性与女性联系起来，这样我就不会将兄弟姐妹（来自同一父母的人）联系起来而且我正在联系所有人。

对于上述示例，对于阵列1和阵列2，链接应该是：11-> 66,22-> 44,33-> 55。对于阵列1和阵列3，它将是11-> 44,22-> 55,33-> 66或任何组合。

我希望我已经清楚地解释了手头的问题。

到目前为止我所做的工作如下：



class Person {
    int id
    String sex
    String parentKey
}
class Pair {
    int id
    Person male
    Person female
}
class Sample {
    static main(args) {
        List<Person> males = [
            [1,'M','p1'],
            [2,'M','p2'],
            [3,'M','p3']
        ]
        List<Person> females = [
                    [4,'F','p1'],
                    [5,'F','p2'],
                    [6,'F','p3']
                ]
        List<Pair> pairs = checkIfCanBePaired(1,males,females)      
        for(Pair p : pairs) {
            println p
        }       
    }
    public static List<Pair> checkIfCanBePaired(int id, List<Person> males, List<Person> females) { 
        List<Pair> pairs = []
        boolean matchFound = false      
        for(int i=0; i < males.size() ; i++) {
            for(int j=0; j < females.size() ; j++) {
                Person m = males.get(i)
                Person f = females.get(j)
                if(m.parentKey != f.parentKey) {
                    matchFound = true
                    Pair p = new Pair(id++,m,f)
                    pairs.add(p)
                    males.remove(i)
                    females.remove(j)
                    pairs.addAll(checkIfCanBePaired(id,males,females))
                }
            }
        }
        return pairs
    }
}

class Person { int id String sex String parentKey } class Pair { int id Person male Person female } class Sample { static main(args) { List<Person> males = [ [1,'M','p1'], [2,'M','p2'], [3,'M','p3'] ] List<Person> females = [ [4,'F','p1'], [5,'F','p2'], [6,'F','p3'] ] List<Pair> pairs = checkIfCanBePaired(1,males,females) for(Pair p : pairs) { println p } } public static List<Pair> checkIfCanBePaired(int id, List<Person> males, List<Person> females) { List<Pair> pairs = [] boolean matchFound = false for(int i=0; i < males.size() ; i++) { for(int j=0; j < females.size() ; j++) { Person m = males.get(i) Person f = females.get(j) if(m.parentKey != f.parentKey) { matchFound = true Pair p = new Pair(id++,m,f) pairs.add(p) males.remove(i) females.remove(j) pairs.addAll(checkIfCanBePaired(id,males,females)) } } } return pairs } }

到目前为止我尝试过的代码就在上面。我被困的地方是，按照上面的代码，1被链接到5，2被链接到4，其中3和6来自同一个父。我如何让它工作，以便1和6被链接？

Answer 1

Java中的数组只能有一种数据类型。您可以使用的是并行数组，其中数组的索引将映射到其他并行数组

例如：

int [] personId = {11,22,33};
char [] sex = {'M', 'M', 'M'};
int [] parentId = {1,2,3};

通过调用personId [0]，sex [0]和parentId [0]，您将能够获得整个记录。

Answer 2

我的解决方案如下：

class Person {
    int id
    String sex
    String parentKey
}
class Pair {
    int id
    Person male
    Person female
}
class Sample {
    static main(args) {
        List<Person> males = [
            [1,'M','p1'],
            [2,'M','p2'],
            [3,'M','p3'],
            [4,'M','p4'],
            [5,'M','p5']
        ]

        List<Person> females = [
                    [6,'F','p1'],
                    [7,'F','p2'],
                    [8,'F','p3'],
                    [9,'F','p4'],
                    [10,'F','p5']
                ]

        Set<Integer> s = new HashSet<Integer>();

        for(int i=0 ; i < females.size() ; i++) {
            s.add(i)    
        }

        List<List<Integer>> permutations = permute(s.toArray(new Integer[0]))

        int index=0     
        boolean canBePaired = false

        while(index < permutations.size()) {
            females = shuffle(females, permutations.get(index))

            if(checkIfCanBePaired(males, females)) {
                canBePaired = true
                break
            }
            index++
        }

        if(canBePaired) {
            println "no. of tries="+(index+1)           
            List<Pair> pairs = pairThem(males, females)
            pairs.each {
                println it
            }
        } else {
            println "cages can't be paired"
        }
    }

    public static List<Person> shuffle(List<Person> person, List<Integer> order) {
        List<Person> reorderedPerson = []

        if(person.size()==order.size()) {
            for(int i=0 ; i<order.size();i++){
                reorderedPerson.add(person.get(order[i]))
            }
        }

        return reorderedPerson
    }

    public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if (nums == null || nums.length == 0) {
            return results;
        }
        List<Integer> result = new ArrayList<>();
        dfs(nums, results, result);
        return results;
    }

    public static void dfs(int[] nums, List<List<Integer>> results, List<Integer> result) {
        if (nums.length == result.size()) {
            List<Integer> temp = new ArrayList<>(result);
            results.add(temp);
        }
        for (int i=0; i<nums.length; i++) {
            if (!result.contains(nums[i])) {
                result.add(nums[i]);
                dfs(nums, results, result);
                result.remove(result.size() - 1);
            }
        }
    }

    public static boolean checkIfCanBePaired(List<Person> males, List<Person> females) {
        int possiblePairs = 0

        if(males.size() <= females.size()) {
            possiblePairs  = males.size()
        } else {
            possiblePairs = females.size()
        }

        for(int i=0 ; i<possiblePairs ; i++) {  
            Person m = males.get(i)
            Person f = females.get(i)

            if(m.parentKey == f.parentKey) {
                return false
            }
        }
        return true
    }

    public static List<Pair> pairThem(List<Person> males, List<Person> females) {   
        List<Pair> pairs = []

        int possiblePairs = 0

        if(males.size() <= females.size()) {
            possiblePairs  = males.size()
        } else {
            possiblePairs = females.size()
        }

        println "no. of males="+males.size()
        println "no. of females="+females.size()
        println "males="+males
        println "females="+females
        println "no. of possible pairs="+possiblePairs

        int pairId = 1

        for(int i=0 ; i<possiblePairs ; i++) {
            pairs.add(new Pair(pairId++, (Person)males.get(i),(Person)females.get(i)))          
        }
        return pairs
    }

}

检查是否可以链接两个阵列

2 个答案: