一道google算法题

来源：互联网发布：ubuntu查看目录编辑：程序博客网时间：2024/05/13 17:26

最近看到一道算法题，突然来了兴致，决定自己实现一遍，看看是否可以用一种比较好的方式来求解这个问题。

下面给出原题：

n 支队伍比赛，分别编号为0，1，2。。。。n-1，已知它们之间的实力对比关系，存储在一个二维数组w[n][n]中，w[i][j] 的值代表编号为i，j 的队伍中更强的一支。所以w[i][j]=i 或者j，现在给出它们的出场顺序，并存储在数组order[n]中，比如order[n] = {4,3,5,8,1......}，那么第一轮比赛就是4 对3， 5 对8。.......
胜者晋级，败者淘汰，同一轮淘汰的所有队伍排名不再细分，即可以随便排，下一轮由上一轮的胜者按照顺序，再依次两两比，比如可能是4 对5,直至出现第一名

编程实现，给出二维数组w，一维数组order 和用于输出比赛名次的数组result[n]，求出result。

注：这道题目来自于互联网，不保证是原题。

话不多说，下面给出我的方案：

其实很简单，这道题里面的实力对比是确定的，每一轮比赛的对手和出场顺序都会随着比赛的进行发生变化，这里我们只知道第一轮比赛的出场顺序和对手，也就是我以后的每一轮比赛结束，我们都必须计算出下一轮比赛的出场顺序以进行下一轮次的比赛，而且我们需要把淘汰的队伍编号记下来，以做排序之用。

我们现在来说说实现，我的思路是

在内存中放置一个stack，用于存放队伍的排名。
每一场比赛结束之后，把取胜的队伍编号放在下一轮出场的位置，比如：第五个和第六个出场的胜者将会是下一轮的第三个出场的队伍。
然后把淘汰的队伍编号放在一个stack中。
一轮比赛结束之后，调整需要比赛队伍的个数，因为两两比赛，所以如果这一轮是基数队伍，将会有一只队伍不参与本轮比赛。这里举个例子，如果这轮有7只队伍比赛，那么只能有六只队伍比赛，一只轮空，下轮比赛将会有这轮的3个胜者和一只本轮轮空的队伍。
一轮比赛结束后，再重复2-4步，直到队伍总数小于两只为止。（说明比赛已经结束）

下面给我的部分实现代码，仅供大家参考：

准备实力对比数组，随机给出一些出场顺序。

           static final int num =10;        int[][] w = new int[num][num];        Random random = new Random();        for(int i = 0; i<num ; i++)        {                         for(int j =i+1; j< num; j++)                         {                                //assign the winner randomly.                                 w[i][j] = w[j][i] =random.nextBoolean() ?i :j ;                                          }                         }                //print out the array               for(int i = 0; i<num ; i++)               {                        for(int j =0; j< num; j++)                         System.out.print(w[i][j] + "\t");                         System.out.println();              }                               int[] order ={1,2,0,4,3,7,8,5,9,6};              int[] result = new int[num];              sort(w, order,num, result);

下面的sort的实现

 static void sort(int w[][],int order[], int n, int result[] )    {        int i =0;        Stack s = new Stack();        int size = n;        while(size > 1)        {            for(i = 0; i< size -1; )            {                if(w[order[i]][order[i+1]] == order[i])                {                    s.push(order[i+1]);                       order[i/2] = order[i];                }                else                {                     s.push(order[i]);                      order[i/2] = order[i+1];                }                             i = i+2;            }            //put the last element into the end of new order array if the size is odd            if(size % 2 ==1)            {                order[size/2] = order[size-1];                        }            //get the new size after this round of competition            size = (size+1)/2;        }        //push the last one        s.push(order[0]);      }

代码就是这些，很简单吧？！

0 0 0 3 4 5 0 0 0 9
0 0 2 3 1 5 1 7 8 1
0 2 0 3 2 5 6 7 2 9
3 3 3 0 3 3 3 7 3 3
4 1 2 3 0 4 6 7 8 4
5 5 5 3 4 0 5 7 5 9
0 1 6 3 6 5 0 6 6 6
0 7 7 7 7 7 6 0 8 9
0 8 2 3 8 5 6 8 0 8
9 1 9 3 4 9 6 9 8 0 下面我们来更加详细的分析算法的运算过程，假设我们的实力对照表如下：

0003450009002315178102032567293330333733412304678455534057590163650666077777608908238568089193496980

至于首轮的出场顺序我们已经hard-code在我们的代码中了： 1,2,0,4,3,7,8,5,9,6

好，接下来我们逐次的推导：

所以我们的结果是： 6 7 2 5 4 9 8 3 0 1

好了，就介绍到这里了，请大家多多指教~~~~~