一道google算法题

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

下面给出原题：

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。

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

 

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

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

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

1. 在内存中放置一个stack，用于存放队伍的排名。
2. 每一场比赛结束之后，把取胜的队伍编号放在下一轮出场的位置，比如：第五个和第六个出场的胜者将会是下一轮的第三个出场的队伍。
3. 然后把淘汰的队伍编号放在一个stack中。
4. 一轮比赛结束之后，调整需要比赛队伍的个数，因为两两比赛，所以如果这一轮是基数队伍，将会有一只队伍不参与本轮比赛。这里举个例子，如果这轮有7只队伍比赛，那么只能有六只队伍比赛，一只轮空，下轮比赛将会有这轮的3个胜者和一只本轮轮空的队伍。
5. 一轮比赛结束后，再重复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 下面我们来更加详细的分析算法的运算过程，假设我们的实力对照表如下：

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	

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

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

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

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