此題目換湯不換藥，阿里巴巴的題目，個體可以為賽車、賽馬、人。
可以作為思維題，也可以為演算法程式設計題，筆試程式碼題，面試程式碼題（手寫）和思維題（口述）。

• 第一步
• 第二步
• 第三步
• 第四步
• 第五步
• 程式設計

第一步

將25個賽車分為5組，每組5個賽車，分別比賽，得出每組的第一名，並對第一名進行排序，為A1, B1, C1, D1, E1；

第二步

A1, B1, C1, D1, E1進行一次比賽，得出第一名，假設為A1，此時經過6輪比賽，得出第一名；

第三步

找第二名第三名；首先第一步中D1, E1排除，同時排除對應組所有賽車；剩A1, B1, C1三組

第四步

第二名可能賽車是A2，B1； 第三名可能賽車是A2，A3, B1，B2, C1

第五步

最後將A2，A3, B1，B2, C1進行一輪比賽，得出第二名第三名，此時總共經過7輪比賽；

程式設計

Java程式碼
轉載——wesleyJava博主給出的解答

package org.algorithm.search;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.Stack;

/**
 * @author yuewei.wangyw
 */
public class FindFastestHorse {

    /** 跑的次數 **/
    public static int times = 0;

    /**
     * 獲得最快的那一匹
     * 
     * @param rootHorse 虛擬節點（最快的那一匹馬）
     * @param runWaySize 跑道個數
     * @return
     */
    public static Horse findMax(Horse rootHorse, int runWaySize) {
        // 跑道
        List<Horse> runWay = new ArrayList<Horse>();
        // 比rootHorse 慢的馬
        List<Horse> slowerHorses = rootHorse.getSlowerHorses();
        // 附加的比較的馬匹，當比rootHorse 慢的馬分組不夠是，需要找更慢的馬，進行比較，從而減少比較次數
        List<Horse> additionHorses = new ArrayList<Horse>();
        // 堆疊，用來實現查詢下一匹馬的遞迴實現
        Stack<Horse> stack = new Stack<Horse>();
        // 跑道個數
        int size = runWaySize;
        // 直到找到最快的馬
        while (slowerHorses.size() > 1) {
            // 清除跑道
            runWay.clear();
            // 清除棧
            stack.clear();
            // 重置
            size = runWaySize;
            // 對比當前rootHorse慢的馬進行分組
            for (Iterator<Horse> iter = slowerHorses.iterator(); iter.hasNext() && size-- > 0;) {
                Horse horse = iter.next();
                runWay.add(horse);
                stack.add(horse);
                iter.remove();
            }
            // 一旦分組不夠，則取更慢的馬
            if (size > 0) {
                // 要麼已經選夠了馬，要麼沒有馬可以選
                while (size > 0 && stack.size() > 0) {
                    Horse currentNode = stack.pop();
                    // 選更慢的馬
                    for (Iterator<Horse> iter = currentNode.getSlowerHorses().iterator(); iter.hasNext() && size-- > 0;) {
                        Horse horse = iter.next();
                        additionHorses.add(horse);
                        stack.add(horse);
                        iter.remove();
                    }
                }
                // 更慢的馬，加入到比賽佇列
                runWay.addAll(additionHorses);
            }
            // 開始賽馬
            Collections.sort(runWay);
            times++;
            // 建立馬匹之間的關係
            for (int i = 0; i < runWay.size() - 1; i++) {
                runWay.get(i).getSlowerHorses().add(runWay.get(i + 1));
            }
            // 將當前比較佇列中最快的馬，加入到比rootHorse慢的馬隊中
            slowerHorses.add(runWay.get(0));
            System.out.println(">>>>第" + times + "次:");
            rootHorse.print();
        }
        // 得到最快的馬，堆排序演算法
        return slowerHorses.get(0);
    }

    /**
     * @param rootHorse
     * @param runWaySize 跑道個數
     * @param maxCount 最快馬的個數
     */
    public static void find(Horse rootHorse, int runWaySize, int maxCount) {
        int i = 1;
        while (maxCount-- > 0) {
            rootHorse = findMax(rootHorse, runWaySize);
            System.out.println("--------第" + i++ + "名:" + rootHorse.getValue());

        }
    }

    public static void main(String args[]) {
        List<Horse> horses = Race.getHourses();
        for (int i = 0; i < horses.size(); i++) {
            System.out.print(horses.get(i).getValue());
            System.out.print(" ");
        }
        Horse horse = new Horse();
        horse.setValue(100);
        horse.setSlowerHorses(horses);
        System.out.println(" ");
        find(horse, 5, 3);
    }
}

/**
 * 賽馬物件資料結構
 * 
 * @author yuewei.wangyw
 */
class Horse implements Comparable<Horse> {

    private int         value;
    private List<Horse> slowerHorses;

    public Horse(){
        slowerHorses = new ArrayList<Horse>();
    }

    public List<Horse> getSlowerHorses() {
        return slowerHorses;
    }

    public void setSlowerHorses(List<Horse> slowerHorses) {
        this.slowerHorses = slowerHorses;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    @Override
    public int compareTo(Horse o) {
        if (o.value > this.value) {
            return 1;
        } else if (o.value < this.value) {
            return -1;
        } else {
            return 0;
        }
    }

    private void print(int level) {
        for (int i = 0; i < level; i++) {
            System.out.print("| ");
        }
        System.out.print("+");
        System.out.println(value);
        for (int i = 0; i < slowerHorses.size(); i++) {
            slowerHorses.get(i).print(level + 1);
        }
    }

    public void print() {
        print(0);
    }
}

/**
 * 生成馬隊
 * 
 * @author yuewei.wangyw
 */
class Race {

    public static List<Horse> getHourses() {
        List<Horse> hourses = new ArrayList<Horse>();
        Random random = new Random();
        random.setSeed(100);
        int rad = 0;
        Set<Integer> set = new HashSet<Integer>();
        while (hourses.size() < 25) {
            rad = random.nextInt(1024) % 25;
            if (!set.contains(rad)) {
                set.add(rad);
                Horse horse = new Horse();
                horse.setValue(rad + 1);
                hourses.add(horse);
            }

        }
        return hourses;
    }
}