Given a family tree, find out if two people are blood related

Posted 2021-01-13 lightwindy

Given a family tree for a few generations for the entire population and two people write a routine that will find out if they are blood related. Siblings are blood related since they have the same parents. Cousins are blood related since one of their parents have the same parents etc. Design the data structure first and then write the routine.

https://www.careercup.com/question?id=4812957531766784

解法：G家，we can use DFS or BFS, DFS is generally a bit easier to implement.

If they have a common ancestor.

Data structure: Graph, becausd two parents. Store parents in an array or list rather than having a separate pointer for the father and mother.

DFS/BFS startig from 1 person is not ideal. BFS/Iterative Deepening for common ancestor from each person, as don‘t process unnecessary children.

Lots of ways to determine a common ancestor. pure recursion, recursively compute the ancestor set of both people and check intersection, iterative deepening to build up the sets.

Java:

For 2 persons to be blood related, perform a Breadth First Traversal with the person as root and the parents as child nodes and store in a ArrayList.
Then for both the persons search is there is a common parent in the ArrayList.
If common parent found then, the persons are related, else not related.

The data structure to store the generation tree will have nodes defined as

public class Person {
	String name;
	ArrayList<Person> children = null;
	Person parent1;
	Person parent2;

	public Person(String personName, Person personParent1, Person personParent2) {
		name = personName;
		children = new ArrayList<Person>();
		parent1 = personParent1;
		parent2 = personParent2;
	}
	public Person getParent() { return parent; }
}

Java:

public class Person {
  Person[] parents;
}

// naming for cousins is: n th cousin m times removed
// where n is the min generations to a common ancestor and m is the number of generations difference between the 2 cousins
// so this is going to be O((2^n+m)+2) which is still more efficient than dfs assuming the num generations in the population is > n+m
public boolean bloodRelated(Person p1, Person p2) {
  // simple search would go down p1‘s children/grandchildren/etc and see if we find p2
  // then vice versa
  // then worry about cousin style relationships
  // here we‘d go up the parent tree on both until we found a common node (or ran out of data)

  // we could take this last approach anyway and it would get us a parent-child match too
  Set<Person> p1Ancestors = new HashSet<Person>();
  Set<Person> p2Ancestors = new HashSet<Person>();

  // so ideally here we‘re going to do BFS, but we‘re going to do 2 at once to try to minimise the depth we have to go
  List<Person> p1Discovered = new LinkedList<Person>();
  p1Discovered.add(p1);
  List<Person> p2Discovered = new LinkedList<Person>();
  p2Discovered.add(p2);

  while (!p1Discovered.isEmpty() || !p2Discovered.isEmpty()) {
    Person nextP1 = p1Discovered.remove(0);
    if (nextP1 != null) {
      if (p2Ancestors.contains(nextP1)) {
        return true;
      }

      for (Person parent : nextP1.parents) {
        p1Discovered.add(parent);
      }
      p1Ancestors.add(nextP1);
    }

    Person nextP2 = p2Discovered.remove(0);
    if (nextP2 != null) {
      if (p1Ancestors.contains(nextP2)) {
        return true;
      }

      for (Person parent : nextP2.parents) {
        p2Discovered.add(parent);
      }
      p2Ancestors.add(nextP2);
    }
  }
  return false;
}