Puzzle: Find the order of n persons standing in a line (based on their heights)

Question

Saw this question on Careercup.com:

Given heights of n persons standing in a line and a list of numbers corresponding to each person (p) that gives the number of pers

Answer 1

I think one approach can be the following. Although it again seems to be O(n^2) at present.

Sort the Height array and corresponding 'p' array in ascending order of heights (in O(nlogn)). Pick the first element in the list. Put that element in the final array in the position given by the p index.

For example after sorting,
H - 1, 2, 3, 4, 5, 6
p - 3, 2, 1, 2, 0, 0.

1st element should go in position 3. Hence final array becomes:
---1--

2nd element shall go in position 2. Hence final array becomes:
--21--

3rd element should go in position 1. Hence final array becomes:
-321--

4th element shall go in position 2. This is the position among the empty ones. Hence final array becomes:
-321-4

5th element shall go in position 0. Hence final array becomes:
5321-4

6th element should go in position 0. Hence final array becomes:
532164

Answer 2

I'm using LinkedList for the this. Sort the tallCount[] in ascending order and accordingly re-position the items in heights[]. This is capable of handling the duplicate elements also.

public class FindHeightOrder {

public int[] findOrder(final int[] heights, final int[] tallCount) {
    if (heights == null || heights.length == 0 || tallCount == null
            || tallCount.length == 0 || tallCount.length != heights.length) {
        return null;
    }
    LinkedList list = new LinkedList();
    list.insertAtStart(heights[0]);
    for (int i = 1; i < heights.length; i++) {
        if (tallCount[i] == 0) {
            Link temp = list.getHead();
            while (temp != null && temp.getData() <= heights[i]) {
                temp = temp.getLink();
            }
            if (temp != null) {
                if (temp.getData() <= heights[i]) {
                    list.insertAfterElement(temp.getData(), heights[i]);
                } else {
                    list.insertAtStart(heights[i]);
                }
            } else {
                list.insertAtEnd(heights[i]);
            }
        } else {
            Link temp = list.getHead();
            int pos = tallCount[i];
            while (temp != null
                    && (temp.getData() <= heights[i] || pos-- > 0)) {
                temp = temp.getLink();
            }
            if (temp != null) {
                if (temp.getData() <= heights[i]) {
                    list.insertAfterElement(temp.getData(), heights[i]);
                } else {
                    list.insertBeforeElement(temp.getData(), heights[i]);
                }
            } else {
                list.insertAtEnd(heights[i]);
            }
        }
    }
    Link fin = list.getHead();
    int i = 0;
    while (fin != null) {
        heights[i++] = fin.getData();
        fin = fin.getLink();
    }
    return heights;
}

public class Link {

    private int data;
    private Link link;

    public Link(int data) {
        this.data = data;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Link getLink() {
        return link;
    }

    public void setLink(Link link) {
        this.link = link;
    }

    @Override
    public String toString() {
        return this.data + " -> "
                + (this.link != null ? this.link : "null");
    }

}

public class LinkedList {

    private Link head;

    public Link getHead() {
        return head;
    }

    public void insertAtStart(int data) {
        if (head == null) {
            head = new Link(data);
            head.setLink(null);
        } else {
            Link link = new Link(data);
            link.setLink(head);
            head = link;
        }
    }

    public void insertAtEnd(int data) {
        if (head != null) {
            Link temp = head;
            while (temp != null && temp.getLink() != null) {
                temp = temp.getLink();
            }
            temp.setLink(new Link(data));
        } else {
            head = new Link(data);
        }
    }

    public void insertAfterElement(int after, int data) {
        if (head != null) {
            Link temp = head;
            while (temp != null) {
                if (temp.getData() == after) {
                    Link link = new Link(data);
                    link.setLink(temp.getLink());
                    temp.setLink(link);
                    break;
                } else {
                    temp = temp.getLink();
                }
            }
        }
    }

    public void insertBeforeElement(int before, int data) {
        if (head != null) {
            Link current = head;
            Link previous = null;
            Link ins = new Link(data);
            while (current != null) {
                if (current.getData() == before) {
                    ins.setLink(current);
                    break;
                } else {
                    previous = current;
                    current = current.getLink();
                    if (current != null && current.getData() == before) {
                        previous.setLink(ins);
                        ins.setLink(current);
                        break;
                    }
                }
            }
        }
    }

    @Override
    public String toString() {
        return "LinkedList [head=" + this.head + "]";
    }

}

}

Answer 3

There exists an algorithm with O(nlogn) average complexity, however worst case complexity is still O(n²).

To achieve this you can use a variation of a binary tree. The idea is, in this tree, each node corresponds to a person and each node keeps track of how many people are in front of him (which is the size of the left subtree) as nodes are inserted.

Start iterating the persons array in decreasing height order and insert each person into the tree starting from the root. Insertion is as follows:

1. Compare the frontCount of the person with the current node's (root at the beginning) value.
2. If it is smaller than it insert the node to the left with value 1. Increase the current node's value by 1.
3. Else, descend to the right by decreasing the person's frontCount by current node's value. This enables the node to be placed in the correct location.

After all nodes finished, an inorder traversal gives the correct order of people.

Let the code speak for itself:

public static void arrange(int[] heights, int[] frontCounts) {
  Person[] persons = new Person[heights.length];

  for (int i = 0; i < persons.length; i++)
    persons[i] = new Person(heights[i], frontCounts[i]);

  Arrays.sort(persons, (p1, p2) -> {
    return Integer.compare(p2.height, p1.height);
  });

  Node root = new Node(persons[0]);

  for (int i = 1; i < persons.length; i++) {
    insert(root, persons[i]);
  }

  inOrderPrint(root);
}


private static void insert(Node root, Person p) {
  insert(root, p, p.frontCount);
}

private static void insert(Node root, Person p, int value) {
  if (value < root.value) { // should insert to the left
    if (root.left == null) {
      root.left = new Node(p);
    } else {
      insert(root.left, p, value);
    }
    root.value++; // Increase the current node value while descending left!
  } else { // insert to the right
    if (root.right == null) {
      root.right = new Node(p);
    } else {
      insert(root.right, p, value - root.value);
    }
  }
}

private static void inOrderPrint(Node root) {
  if (root == null)
    return;

  inOrderPrint(root.left);

  System.out.print(root.person.height);

  inOrderPrint(root.right);
}

private static class Node {
  Node left, right;
  int value;
  public final Person person;

  public Node(Person person) {
    this.value = 1;
    this.person = person;
  }
}

private static class Person {
  public final int height;
  public final int frontCount;

  Person(int height, int frontCount) {
    this.height = height;
    this.frontCount = frontCount;
  }
}

public static void main(String[] args) {
  int[] heights = {5, 3, 2, 6, 1, 4};
  int[] frontCounts = {0, 1, 2, 0, 3, 2};

  arrange(heights, frontCounts);
}

Answer 4

This is the implementation for the idea provided by user1990169. Complexity being O(N^2).

public class Solution {
        class Person implements Comparator<Person>{
            int height;
            int infront;
            public Person(){

            }
            public Person(int height, int infront){
                this.height = height;
                this.infront = infront;
            }
            public int compare(Person p1, Person p2){
                return p1.height - p2.height;
            }
        }

        public ArrayList<Integer> order(ArrayList<Integer> heights, ArrayList<Integer> infronts) {
           int n = heights.size();
           Person[] people = new Person[n];
           for(int i = 0; i < n; i++){
               people[i] = new Person(heights.get(i), infronts.get(i));
           }

           Arrays.sort(people, new Person());


           Person[] rst = new Person[n];
           for(Person p : people){
               int count = 0;
               for(int i = 0; i < n ; i++){
                     if(count == p.infront){
                        while(rst[i] != null && i < n - 1){
                            i++;
                        }
                        rst[i] = p;
                        break;
                    }
                    if(rst[i] == null) count++;
               }

            }
            ArrayList<Integer> heightrst = new ArrayList<Integer>();
            for(int i = 0; i < n; i++){
                heightrst.add(rst[i].height);
            }
            return heightrst;
        }
    }

Answer 5

Simple O(n^2) solution for this in Java:

Algorith:

1. If the position of the shortest person is i, i-1 taller people will be in front of him.
2. We fix the position of shortest person and then move to second shortest person.
3. Sort people by heights. Then iterate from shortest to tallest. In each step you need an efficient way to put the next person to the correct position.

4. We can optimise this solution even more by using segment tree. See this link.

   class Person implements Comparable<Person>{
       int height;
       int pos;
   
       Person(int height, int pos) {
           this.height = height;
           this.pos = pos;
       }
   
       @Override
       public int compareTo(Person person) {
           return this.height - person.height;
       }
   }
   
   public class Solution {
       public int[] order(int[] heights, int[] positions) {
           int n = heights.length;
           int[] ans = new int[n];
           PriorityQueue<Person> pq = new PriorityQueue<Person>();
           for( int i=0; i<n; i++) {
               pq.offer(new Person(heights[i], positions[i]) );
           }
   
           for(int i=0; i<n; i++) {
               Person person = pq.poll();
               int vacantTillNow = 0;
               int index = 0;
               while(index < n) {
                   if( ans[index] == 0) vacantTillNow++;
                   if( vacantTillNow > person.pos) break;
                   index++;
               }
               ans[index] = person.height;
           }
           return ans;
       }
   }