public class TwoSidedDecision { 
  private int num = 10;//个体数目 
  private boolean maxFlag = true;//是否求最大值 
  private int[][] scoreArray;//AB之间的互评得分 
  private int[] decisionArray;//A选择B的方式 
}   

public void setNum(int num) { 
  if (num < 1) { 
    System.out.println("num must be greater than 0"); 
    return; 
  } 
  this.num = num; 
} 

public void setScoreArray(int[][] scoreArray) { 
  if (scoreArray == null) { 
    System.out.println("scoreArray is null"); 
  } 
  if (!(scoreArray.length == num && scoreArray[0].length == num)) { 
    System.out.println("scoreArray`s must be " + num); 
  } 
  this.scoreArray = scoreArray; 
  decisionArray = new int[num]; 
  //初始决策，对角线 
  for (int i = 0; i < num; i++) { 
    decisionArray[i] = i; 
  } 
  decision(); 
} 

private boolean compare(int stepSize) { 
  for (int i = 0; i < num - stepSize; i++) { 
    int a1 = i; 
    int a2 = i + stepSize; 
    int b1 = decisionArray[a1]; 
    int b2 = decisionArray[a2]; 
    //原始两个得分之和 
    int score1 = scoreArray[a1][b1] + scoreArray[a2][b2]; 
    int between1 = Math.abs(scoreArray[a1][b1] - scoreArray[a2][b2]); 
    //交换后的两个得分之和 
    int score2 = scoreArray[a1][b2] + scoreArray[a2][b1]; 
    int between2 = Math.abs(scoreArray[a1][b2] - scoreArray[a2][b1]); 
    if (maxFlag) { //最后的得分最大 
      if (score1 <= score2) {//交换后的分数不小于交换前的 
        //交换后的分数大于交换前的或者交换后的差值大于交换前的 
        if (score1 < score2 || between2 > between1) { 
          decisionArray[a1] = b2; 
          decisionArray[a2] = b1; 
          return true; 
        } 
      } 
    } else { //最后的得分最小 
      if (score1 >= score2) {//交换后的分数不小于交换前的 
        //交换后的分数大于交换前的或者交换后的差值大于交换前的 
        if (score1 > score2 || between2 > between1) { 
          decisionArray[a1] = b2; 
          decisionArray[a2] = b1; 
          return true; 
        } 
      } 
    } 
  } 
  return false; 
} 

 /**  
 *@Description: 双边匹配决策算法 
 */  
package com.lulei.twosided.matching.decisionmaking;  
 
import com.lulei.util.JsonUtil; 
  
public class TwoSidedDecision { 
  private int num = 10;//个体数目 
  private boolean maxFlag = true;//是否求最大值 
  private int[][] scoreArray;//AB之间的互评得分 
  private int[] decisionArray;//A选择B的方式 
   
  public boolean isMaxFlag() { 
    return maxFlag; 
  } 
 
  public void setMaxFlag(boolean maxFlag) { 
    this.maxFlag = maxFlag; 
  } 
 
  /** 
   * @return 
   * @Author:lulei  
   * @Description: 获得最后的决策 
   */ 
  public int[] getDecisionArray() { 
    return decisionArray; 
  } 
   
  /** 
   * @return 
   * @Author:lulei  
   * @Description: 获取决策的评分 
   */ 
  public int getScoreSum() { 
    int sum = 0; 
    for (int i = 0; i < num; i++) { 
      sum += scoreArray[i][decisionArray[i]]; 
    } 
    return sum; 
  } 
 
  /** 
   * @param num 
   * @Author:lulei  
   * @Description: 设置双边决策个体个数 
   */ 
  public void setNum(int num) { 
    if (num < 1) { 
      System.out.println("num must be greater than 0"); 
      return; 
    } 
    this.num = num; 
  } 
   
  /** 
   * @param scoreArray 
   * @Author:lulei  
   * @Description: 设置A类个体与B类个体间的评价 
   */ 
  public void setScoreArray(int[][] scoreArray) { 
    if (scoreArray == null) { 
      System.out.println("scoreArray is null"); 
    } 
    if (!(scoreArray.length == num && scoreArray[0].length == num)) { 
      System.out.println("scoreArray`s must be " + num); 
    } 
    this.scoreArray = scoreArray; 
    decisionArray = new int[num]; 
    //初始决策，对角线 
    for (int i = 0; i < num; i++) { 
      decisionArray[i] = i; 
    } 
    decision(); 
  } 
   
  /** 
   * @Author:lulei  
   * @Description: 计算最优决策 
   */ 
  private void decision() { 
    if (scoreArray == null || decisionArray == null) { 
      System.out.println("please init scoreArray"); 
    } 
    for (int stepSize = 1; stepSize < num; stepSize++) { 
      //特定步长下的交换 
      while (compare(stepSize)); 
    } 
  }  
   
  /** 
   * @param stepSize 
   * @return 
   * @Author:lulei  
   * @Description: 特定步长比较，返回值确认是否发生交换 
   */ 
  private boolean compare(int stepSize) { 
    for (int i = 0; i < num - stepSize; i++) { 
      int a1 = i; 
      int a2 = i + stepSize; 
      int b1 = decisionArray[a1]; 
      int b2 = decisionArray[a2]; 
      //原始两个得分之和 
      int score1 = scoreArray[a1][b1] + scoreArray[a2][b2]; 
      int between1 = Math.abs(scoreArray[a1][b1] - scoreArray[a2][b2]); 
      //交换后的两个得分之和 
      int score2 = scoreArray[a1][b2] + scoreArray[a2][b1]; 
      int between2 = Math.abs(scoreArray[a1][b2] - scoreArray[a2][b1]); 
      if (maxFlag) { //最后的得分最大 
        if (score1 <= score2) {//交换后的分数不小于交换前的 
          //交换后的分数大于交换前的或者交换后的差值大于交换前的 
          if (score1 < score2 || between2 > between1) { 
            decisionArray[a1] = b2; 
            decisionArray[a2] = b1; 
            return true; 
          } 
        } 
      } else { //最后的得分最小 
        if (score1 >= score2) {//交换后的分数不小于交换前的 
          //交换后的分数大于交换前的或者交换后的差值大于交换前的 
          if (score1 > score2 || between2 > between1) { 
            decisionArray[a1] = b2; 
            decisionArray[a2] = b1; 
            return true; 
          } 
        } 
      } 
    } 
    return false; 
  } 
 
  public static void main(String[] args) { 
    int[][] scoreArray = { 
        {0,1,2,3,4,5,6,7,8,9}, 
        {1,2,3,4,5,6,7,8,9,0}, 
        {2,3,4,5,6,7,8,9,0,1}, 
        {3,4,5,6,7,8,9,0,1,2}, 
        {4,5,6,7,8,9,0,1,2,3,}, 
        {5,6,7,8,9,0,1,2,3,4}, 
        {6,7,8,9,0,1,2,3,4,5}, 
        {7,8,9,0,1,2,3,4,5,6}, 
        {8,9,0,1,2,3,4,5,6,7}, 
        {9,0,1,2,3,4,5,6,7,8}}; 
    TwoSidedDecision test = new TwoSidedDecision(); 
    test.setNum(10); 
    test.setMaxFlag(false); 
    test.setScoreArray(scoreArray); 
    System.out.println("最优决策"); 
    System.out.println(JsonUtil.parseJson(test.getDecisionArray())); 
    System.out.println("决策得分"); 
    System.out.println(test.getScoreSum()); 
  } 
 
}