题目：
       有4名同学参加数学竞赛，3个老师对他们的名次进行的预测。每一个老师只预测两个同学的排名。而竞赛结果表明每一个老师都预测对了一半。编写一个程序，使它能能根据老师的预测得到正确的结果。
注意：
      老师的预测内容是不固定的。但老师的人数是固定的，只有3个。学生的人数也是固定的，只有4个。并且一定可以根据老师的预测得到正确的排名。

1. package mytest;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. public class Test14 {
   
6. 
   
7.         /**
   
8.          * 竞赛结果表明，他们都说对了一半，说错了一半，并且无并列名次，试编程输出a,b,c,d的各个名次。
   
9.          * 分析：
   
10.          * 我们将老师的预测列成二维数组形式。行数是老师的人数，也就是3.列数为5。
    
11.          * 第一列表示该老师预测对的个数。由于一个老师预测了两部分，所以将初始值都设置为2.
    
12.          * 我们首先假设第一个老师的第一部分预测时对的，那么就需要将预测了同一人，预测了同一名次，
    
13.          * 以及第一个老师的另一部分预测全部设置为null，并且将相应的预测数减1.直到某一个预测数为0时，
    
14.          * 那么这个假设就是错误的。
    
15.          * @param args
    
16.          */
    
17.         public static void main(String[] args) {
    
18.                 String[][] str = new String[3][5];
    
19.                 for(int x = 0;x<3;x++){
    
20.                         str[x][0] = 2+"";
    
21.                 }
    
22.                 System.out.println("注意：输入时人与名次用等号连接，人与人之间用逗号隔开。");
    
23.                 for(int x = 1;x<=3;x++){
    
24.                         System.out.print("请输入第"+x+"个老师的预测：");
    
25.                         Scanner sc = new Scanner(System.in);
    
26.                         String a = sc.next();
    
27.                         int firstd = a.indexOf("=");
    
28.                         int lastd = a.lastIndexOf("=");
    
29.                         int dou = a.indexOf(",");
    
30.                         str[x-1][Integer.parseInt(a.substring(firstd+1,dou))] = a.substring(0, firstd);
    
31.                         str[x-1][Integer.parseInt(a.substring(lastd+1))] = a.substring(dou+1, lastd);
    
32.                 }
    
33.                 String[][] bei = new String[3][5];//将数组备份，方便还原。
    
34.                 bei= fu(str,bei);
    
35.                         //由于第一个老师肯定会预测对一个，所以不需要进行行的遍历。
    
36.                         for(int y = 1;y<5;y++){
    
37.                                 if(str[0][y] == null)
    
38.                                         continue;
    
39.                                 //假设第一个老师的当前预测是正确的，那么需要进行判断。
    
40.                                 boolean b = hanshu(0,y,str);
    
41.                                 //如果b是真的，那么就需要将所有的地方都进行一次判断。
    
42.                                 //因为还有可能存在别的相矛盾的预测。
    
43.                                 if(b){
    
44.                                         k:for(int m = 1;m<3;m++){//第一个老师的正确预测已经假设过了，所以不需要从0开始。
    
45.                                                 for(int n = 1;n<5;n++)
    
46.                                                         if(str[m][n]!=null){
    
47.                                                                 b = b&&hanshu(m,n,str);
    
48.                                                                 if(!b)//如果某个预测出现了错误，那么就直接跳出循环即可。
    
49.                                                                         break k;//跳出最外层，因为这个假设不对。
    
50.                                                         }
    
51.                                         }
    
52.                                 }
    
53.                                 if(b){//如果当前假设成立，那么遍历输出相应的结果。
    
54.                                         for(int x1 = 0;x1<3;x1++){
    
55.                                                 for(int y1 = 1;y1<5;y1++){
    
56.                                                         if(str[x1][y1]!=null)
    
57.                                                                 System.out.println(str[x1][y1]+"是第"+y1+"名");
    
58.                                                 }
    
59.                                         }
    
60.                                 }
    
61.                                 else{
    
62.                                         if(y == 4){//当第一个老师的所有预测都是错误的时候，题目就无法完成了。
    
63.                                                 System.out.println("无法推断出名次。");
    
64.                                                 break;
    
65.                                         }
    
66.                                         str = fu(bei,str);//通过上面的操作，已经将str进行了改变，所以需要还原。
    
67.                                 }
    
68.                         }
    
69.         }
    
70.         //改变同行、同列以及相同的人后，判断是不是出现错误。
    
71.         private static boolean hanshu(int col, int row, String[][] str) {
    
72.                 boolean b= false;
    
73.                 for(int x = 0;x<3;x++){
    
74.                         for(int y = 1;y<5;y++){
    
75.                                 b= false;//每一个位置开始时假设没有发生变化。
    
76.                                 if(str[x][y]!=null){
    
77.                                         if(x == col&&y!=row){//同行不同列
    
78.                                                 str[x][y] = null;
    
79.                                                 b = true;
    
80.                                         }
    
81.                                         else if( y == row&&x!=col){//同列不同行
    
82.                                                 str[x][y] = null;
    
83.                                                 b = true;
    
84.                                         }
    
85.                                         else if(str[x][y].equals(str[col][row])&&x!=col&&y!=row){//即不同列也不同行，但是预测的人是一样的。
    
86.                                                 str[x][y] = null;
    
87.                                                 b = true;
    
88.                                         }
    
89.                                         if(b){//如果该位置发生了变化，那么就将它所在的行的预测数减1.
    
90.                                                 str[x][0] = Integer.parseInt(str[x][0])-1+"";
    
91.                                                 if(str[x][0].equals("0"))
    
92.                                                         return false;
    
93.                                         }
    
94.                                 }
    
95.                         }                               
    
96.                 }
    
97.                 return true;
    
98.         }
    
99.         //将String[][]还原。
    
100.         private static String[][] fu(String[][] o,String[][] b){
     
101.                 for(int x = 0;x<o.length;x++)
     
102.                         for(int y = 0;y<o[x].length;y++)
     
103.                                 b[x][y] = o[x][y];
     
104.                 return b;
     
105.                
     
106.         }
     
107. }

复制代码