一. AHP层次分析法简介
层次分析法(Analytic Hierarchy Process，简称AHP )是对一些复杂模糊问题进行决策的简单方法。
这特别适用于难以进行完全定量分析的问题。 这是美国物流学家phdyl教授在70年代初期提出的简便、
一种灵活实用的基于多准则决策方法。
1层次分析法的基本原理和步骤
人们在对社会、经济和科学管理领域问题进行系统分析时，往往面临着诸多相互联系、相互制约的因素
这是一个容易缺乏复杂定量数据的系统。 层次分析法为这类问题的决策和排序提供了一种新的、简洁实用的建模方法。
使用层次分析法的模型化大致可以通过以下4个步骤来进行。
(I )建立分层结构模型
(ii )构建各级中的所有判断矩阵
(iii )分层排序和一致性检查
(iv )分层总排序和一致性检查。
双层次结构的构建与表征
应用AHP分析决策问题时，首先要对问题进行理化、分层，建立层次结构模型。
在这个模型中，复杂的问题被分解为要素的构成要素。 这些要素还通过其属性和关系形成几个层次。
上一级要素作为基准支配下一级的相关要素。 这些级别可以分为以下三类：
) I )顶级)这个级别只有一个要素。 一般也称为目标水平，因为它是分析问题的目标或理想结果。
(ii )中间层)该层次包括参与实现目标的中间阶段，可以包括几个层次，包括要考虑的指导方针、子指导方针。
因此，也称为基准层。
(iii )最底层)此层次包括可为实现目标而选择的各种措施、决策方案等，因此也称为措施层或方案层。
分层结构中的层数与问题的复杂程度和有待分析的详细程度有关，一般地层次数不受限制。
各阶层各元素支配的元素通常不要超过9个。 这是因为，支配的元素过多会给两个比较判断带来困难。
Java代码：
package boke.ahp；
import java.math.BigDecimal；
import java.util.Arrays；
//*
*用AHP层次分析法计算权重
*
* @since jdk1.6
* @author急速的秋天
* @版本1.0
* @date 2010.05.25
*
*/
公共类ahpcomputeweight {
//*
* @param args
*/
publicstaticvoidmain (string [ ] args ) {
/** a是N*N矩阵*/
double [ ] [ ] a=new double [ ] [ ] { 1，3，5，1，3 }，
{1/3.0、1、2、1/3.0、1/4.0}、
{1/5.0，1/2.0，1，1/3.0，1/2.0 }，{ 1，3，3，1，1 }，
{1/3.0，4，2，1，1 }；
int N=a[0].length；
double[] weight=new double[N]；
ahpcomputeweightinstance=ahpcomputeweight.getinstance (；
instance.Weight(a，weight，n )；
system.out.println (arrays.tostring ) weight )；
}
//一例
privatestaticfinalahpcomputeweightacw=newahpcomputeweight (；
//平均随机完整性指针
private double [ ] ri={ 0.00，0.00，0.58，0.90，1.12，1.21，1.32，1.41，
1.45，1.49 }；
//随机一致率
专用双精度Cr=0.0；
//最大特征值
private double lamta=0.0；
//*
*私人结构
*/
private AHPComputeWeight (
}
//*
*回到单盒
*
* @return
*/
publicstaticahpcomputeweightgetinstance (
return acw；
}
//*
*计算权重
*
* @param a
* @param weight
* @param N
*/
publicvoidweight(double[][]a，double[] weight，int N ) ) ) ) ) ) ) ) 65
//初始向量Wk
double[] w0=new
double[N];for (int i = 0; i < N; i++) {
w0[i] = 1.0 / N;
}
// 一般向量W（k+1）
double[] w1 = new double[N];
// W（k+1）的归一化向量
double[] w2 = new double[N];
double sum = 1.0;
double d = 1.0;
// 误差
double delt = 0.00001;
while (d > delt) {
d = 0.0;
sum = 0;
// 获取向量
int index = 0;
for (int j = 0; j < N; j++) {
double t = 0.0;
for (int l = 0; l < N; l++)
t += a[j][l] * w0[l];
// w1[j] = a[j][0] * w0[0] + a[j][1] * w0[1] + a[j][2] * w0[2];
w1[j] = t;
sum += w1[j];
}
// 向量归一化
for (int k = 0; k < N; k++) {
w2[k] = w1[k] / sum;
// 最大差值
d = Math.max(Math.abs(w2[k] - w0[k]), d);
// 用于下次迭代使用
w0[k] = w2[k];
}
}
// 计算矩阵最大特征值lamta，CI，RI
lamta = 0.0;
for (int k = 0; k < N; k++) {
lamta += w1[k] / (N * w0[k]);
}
double CI = (lamta - N) / (N - 1);
if (RI[N - 1] != 0) {
CR = CI / RI[N - 1];
}
// 四舍五入处理
lamta = round(lamta, 3);
CI = round(CI, 3);
CR = round(CR, 3);
for (int i = 0; i < N; i++) {
w0[i] = round(w0[i], 4);
w1[i] = round(w1[i], 4);
w2[i] = round(w2[i], 4);
}
// 控制台打印输出
System.out.println("lamta=" + lamta);
System.out.println("CI=" + CI);
System.out.println("CR=" + CR);
// 控制台打印权重
System.out.println("w0[]=");
for (int i = 0; i < N; i++) {
System.out.print(w0[i] + " ");
}
System.out.println("");
System.out.println("w1[]=");
for (int i = 0; i < N; i++) {
System.out.print(w1[i] + " ");
}
System.out.println("");
System.out.println("w2[]=");
for (int i = 0; i < N; i++) {
weight[i] = w2[i];
System.out.print(w2[i] + " ");
}
System.out.println("");
}
/**
* 四舍五入
*
* @param v
* @param scale
* @return
*/
public double round(double v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 返回随机一致性比率
*
* @return
*/
public double getCR() {
return CR;
}
}