Primeiro, vamos ver a pergunta,

Um circo está projetando uma rotina de torre composta por pessoas em pé sobre os ombros umas das outras. Por razões práticas e estéticas, cada pessoa deve ser mais baixa e mais leve que a pessoa abaixo dela. Dadas as alturas e pesos de cada pessoa no circo, escreva um método para calcular o maior número possível de pessoas em uma torre assim.

EXAMPLE:
Input:
        (ht, wt): (65, 100) (70, 150) (56, 90) (75, 190) (60, 95) (68, 110)
Output: The longest tower is length 6 and includes from top to bottom: 
        (56, 90) (60,95) (65,100) (68,110) (70,150) (75,190)

Mas não entendo bem a solução da seguinte maneira:

Solução proposta pelo livro:

Etapa 1. Classifique todos os itens primeiro pela altura e depois pelo peso. Isso significa que, se todas as alturas forem únicas, os itens serão classificados por sua altura. Se as alturas forem iguais, os itens serão classificados por peso. Exemplo: »» Antes da classificação: (60, 100) (70, 150) (56, 90) (75, 190) (60, 95) (68.110). »Após a classificação: (56, 90), (60, 95), (60.100), (68, 110), (70.150), (75.190).

Etapa 2. Encontre a sequência mais longa que contém alturas e pesos crescentes. Para fazer isso, nós:

a) Comece no início do
seqüência. Atualmente, max_sequence está vazio.

b) Se, para o próximo item, o
altura e peso não sejam maiores que os do item anterior, nós
marque este item como "impróprio"

c) Se a sequência encontrada tiver mais itens que "sequência máxima", ela se tornará "sequência máxima".

d) Depois que a pesquisa for repetida a partir do "item impróprio",
até chegarmos ao final do
sequência original.

public class Question {
ArrayList<HtWt> items;
ArrayList<HtWt> lastFoundSeq;
ArrayList<HtWt> maxSeq;


/ Returns longer sequence
ArrayList<HtWt> seqWithMaxLength(ArrayList<HtWt> seq1, ArrayList<HtWt> seq2) {
    return seq1.size() > seq2.size() ? seq1 : seq2;
}


// Fills next seq w decreased wts&returns index of 1st unfit item.
int fillNextSeq(int startFrom, ArrayList<HtWt> seq) {
  int firstUnfitItem = startFrom;
  if (startFrom < items.size()) {
      for (int i = 0; i < items.size(); i++) {
        HtWt item = items.get(i);
        if (i == 0 || items.get(i-1).isBefore(item)) {
            seq.add(item);
        } else {
            firstUnfitItem = i;
        }
      }
  }
  return firstUnfitItem;
}


// Find the maximum length sequence
void findMaxSeq() {
  Collections.sort(items);
  int currentUnfit = 0;
  while (currentUnfit < items.size()) {
      ArrayList<HtWt> nextSeq = new ArrayList<HtWt>();
      int nextUnfit = fillNextSeq(currentUnfit, nextSeq);
      maxSeq = seqWithMaxLength(maxSeq, nextSeq);
      if (nextUnfit == currentUnfit) 
        break;
      else 
        currentUnfit = nextUnfit;
  }
}

}

Pergunta, questão,

1> qual é o uso da função fillNextSeq? 2> por que verificar "items.get (i-1) .isBefore (item)" em vez de comparar o item atual com o mais recente no seq?

Suponha que a lista de classificação seja (1, 5), (2, 1), (2, 2), com base na função de fillNextSeq,

primeiro (1, 5) será empurrado para a sequência. Então o item (2, 1) não será empurrado para a sequência b / c, o peso de (2,1) é menor que (1, 5). A seguir, como (2, 1) é anterior a (2, 2), então (2, 2) será empurrado para a sequência.

Agora, a sequência contém (1, 5) e (2, 2) que não está correto b / c, o peso de (1, 5) é maior que o de (2, 2).

Obrigado