AHP-层次分析法(C++源码，附详细注释和样例）

2021-09-28 06:47:44

算法简介

AHP-层次分析法是数学建模中的常用算法，其适用于一批非常广泛的问题，综合来说，它是一个“层次权重决策分析方法”。客观地讲，它适用于一些有限制条件的决策选择问题:

1.    决策有限，且只从有限的候选决策里选择。
2.    决策的影响因素已知，因素的关系（包括隶属关系和优先级关系）已知
3.    因素的关系不论客观与否，要通过合理性校验，即必须是合理的关系才能导出合理的决策。


算法流程

以下例子以旅游选地点为例。

数据统计阶段

步骤1.获取目标层和决策层，对于旅游问题来说，需要得到候选旅游地点作为决策层，目标层为最后得出的决策。

步骤2.获取中间层信息。除决策层外的每一节点（包括中间层的所有节点和目标层节点），与影响它的节点相连，构造阶梯层次结构，保证为一个有且仅有层与层之间连边的分层图。大概样子如下(from维基）：

AHP-层次分析法(C++源码，附详细注释和样例）

    当然，中间层可以不止一层，层与层之间也不一定是全连边的，比如：

AHP-层次分析法(C++源码，附详细注释和样例）

步骤3.构造成对比较矩阵，对每一个除最底层（决策层，所有的Alternative）的节点，构造该点的成对比较矩阵。该点的成对比较矩阵的含义是所有影响它的因素两两之间的优先级关系。比如上图中Criterion的成对比较矩阵应是一个表示两个Subcriterion优先级关系的2x2矩阵；Criterion2的成对比较矩阵则是4个蓝色的Subcriterion优先级关系的4x4矩阵。

    而优先级关系，一般情况下只用1~9的整数数值来表示。我想一个原因是这个关系通常是主观得到的，过于精细或者过于大的数值都失去了意义；另一个原因在后面会提到，一般情况下设置为1~9已经足够通过合理性（或者叫做一致性检验）了。

一致性检验

    一致性检验是整个决策算法可以实施的最为重要的一步，无论你前面的元素关系和成对比较矩阵怎么设置，如果检验结果很差，那么说明优先级关系不太合理（比如A：B=3，B:C=3，A:C=1/9这种不合理的情况）。检验的结果主要依赖于单个矩阵的一致性检验，和综合情况的一致性检验。


    检验的目的主要是判定整个决策过程是否是基于某个近似“所有元素都有一个假想权值”的情况。该问题的本质，也就是求出这组假象的权值，使得我们可以根据这组权值轻松地作出决策。所以一致性检验做的，并不是检查是否有错误的优先级关系，而是检查是否所有的优先级关系满足或近似满足上述“所有元素都有一个假想权值”的情况，越靠近这种情况，检验结果越好。


一致性检验:单个矩阵的一致性检验

    单个矩阵的检验的目的，就是为了定量得出该矩阵与“一致阵”的“差距”。


    所谓一致阵A，定义上讲，就是对任意i,j,k，成立Aik*Akj=Aij。通俗地讲，就是存在一组权值，A的每一个位Aij都代表了权值i和权值j的比值。显然，一致阵是最合理的成对比较矩阵。一致阵的例子：


ω:

ω1 ω2 ω3 ω4 ω5


A:

1 ω1/ω2 ω1/ω3 ω1/ω4 ω1/ω5
ω2/ω1 1 ω2/ω3 ω2/ω4 ω2/ω5
ω3/ω1 ω3/ω2 1 ω3/ω4 ω3/ω5
ω4/ω1 ω4/ω2 ω4/ω3 1 ω4/ω5
ω5/ω1 ω5/ω2 ω5/ω3 ω5/ω4 1

    

    我们自己设定的矩阵一般都不是一致阵，怎样衡量它和一致阵的“差距”？


    先考虑这种情况，如果我们已知一致阵，但不知道权值向量，我们怎么通过矩阵求权向量？答案很简单，就是求该一致阵的最大特征根（等于n），然后求出该特征根对应的特征向量作为权值向量（各个行/列向量都对应特征根n），其实任意一行/列都能看出权向量的关系不是么？


    考虑矩阵不是一致阵的情况，因此我们可以类似地先求出矩阵的最大特征根λ，再求出λ对应的归一化权向量ω（以后统称权向量）就可以了,则有Aω=λω，这个称为特征根法。归一化的目的是为了计算每个点的实际选择权值（每层实际和值为1），或称到达“概率”。


    可知λ≥n，在A不是一致阵的情况下，有λ>n,因此我们可以用λ-n的数值来衡量A的与一致阵的“差距”。由此可以定义一致性指标：

    

    接下来的问题是——如何判断这个CI是合格的？


    定义 随机一致性指标RI，代表了在矩阵随机的情况下，矩阵的一致性指标的CI的均值。当然我们不能枚举所有可能的矩阵，所以用随机构造大量成对比较矩阵的方法来近似得到这个均值。


    定义 一致性合格比Δ，只要我们构造的那个成对比较矩阵的CI<RI*Δ,就可以认为我们的矩阵是通过一致性检验的，即它是合理的。一般取Δ=0.1。不太恰当但通俗地说，如果你构造的矩阵A，它与一致性矩阵的“差距”比随机情况下的“差距”乘上Δ还要小，我们认为A是合格的成对比较矩阵。


一致性检验：综合情况的一致性检验

    我们已经可以判断每一个成对比较矩阵是否是“合理”的了，那么怎么判断它们综合起来是否合理呢？


    现在所有成对比较矩阵均是合理的，那么对于目标层和第一中间层来说，已经可以求出第一层的到达“概率”，也就是我们求得的目标层权向量，它代表了第一层中间层的每一个元素对于目标层的“重要性”，那么对于第二中间层来说，每个元素的“重要性”是通过目标层的权向量和第一层每个元素的权向量加权相乘得到的。我们要求的就是决策层的到达“概率”


    另外一个考量就是，因为可以通过每层的权向量和层与层之间的连边关系求出最后一层的到达“概率”了，所以最后一层（决策层）的到达“概率”就足以决定目标层的决策了。这也符合我们的预期：从决策层找到权值最大的一个最为目标层的决策。所以检验步骤最后的最后，就是检验决策层的权向量是否“合理”。


    利用已经计算出的一些CI、RI值，定义

    其中这m个CI和RI值分别是最后一层中间层（决策层的上一层）的成对比较矩阵的CI和RI值。只要CR <Δ，就认为通过了综合情况的一致性检验。

一致性检验：如果通不过一致性检验

    如果构造的成对比较矩阵通过了一致性检验，那么可以直接用决策层的到达“概率”，取出值最大的决策就可以了。如果通不过一致性检验，则应该考虑重新统计每个成对比较矩阵了。不合理的优先级关系导出的最优决策是不适合作为最优决策的。


得出决策

    由于是树形层次结构，我们只要从目标层广度遍历所有点，求出决策层的到达“概率”就可以了。理论上我们应该选择到达“概率”最大的决策作为目标决策。

C++源码

[cpp] view plaincopy
  1. #include<iostream>  
  2. #include<cstring>  
  3. #include<cstdio>  
  4. using namespace std;  
  5. struct node{  
  6.     int child[256]; //每个节点的儿子数字，child[0]为儿子个数   
  7.     char name[256]; //节点的名称   
  8.     double** comp;  //该节点概率下的下一层成对比较矩阵   
  9.     double CI;      //CI值   
  10.     double* w;      //最大特征值对应的特征向量   
  11.     double p;       //到达该节点的概率   
  12.     double value;   //只对方案层有效，选取该方案的权重   
  13. }* Node;  
  14. struct level{  
  15.     int num, start_id;//每一层的点数，和起始点的编号   
  16. }* L;  
  17. int n_level, n_node; //总层数，总点数   
  18. /* 
  19.  * 初始化经验RI数组  
  20.  */  
  21. double RI[12]={0,0,0.58,0.9,1.12,1.24,1.32,1.41,1.45,1.49,1.51};  
  22. /* 
  23.  * 寻找字符c在字符串s中的位置，不存在返回-1 
  24.  */   
  25. int pos(char c, char* s){  
  26.     int len = strlen(s);  
  27.     for (int i = 0; i < len; i++){  
  28.         if (s[i] == c) return i;  
  29.     }    
  30.     return -1;  
  31. }  
  32. /* 
  33.  * 读入一个double或者分数形式的数字  
  34.  */  
  35. void myScanf(double* p){  
  36.     char value[256];  
  37.     scanf("%s",value);  
  38.     int place;  
  39.     if ((place = pos('/', value))>0){  
  40.        int f = 0, b = 0;  
  41.        for (int i = 0; i < place; i++){  
  42.            f = f * 10 + value[i] - '0';  
  43.        }  
  44.        for (int i = place + 1; i < strlen(value); i++){  
  45.            b = b * 10 + value[i] - '0';  
  46.        }  
  47.        *p = 1.0 * f / b;  
  48.     } else{  
  49.        *p = 0;  
  50.        for (int i = 0; i < strlen(value); i++){  
  51.            *p = *p * 10 + value[i] - '0';  
  52.        }  
  53.     }  
  54. }  
  55. /* 
  56.  * 数据输入过程  
  57.  */  
  58. void input()  
  59. {  
  60.     printf("输入总层数，包括目标层和方案层:\n");  
  61.     scanf("%d", &n_level);  
  62.     printf("已输入\n");  
  63.        
  64.     L = new level[n_level];  
  65.     n_node = 0;  
  66.     printf("从上往下，输入每层个数:\n");  
  67.     for (int i = 0; i < n_level; i++){  
  68.         scanf("%d",&L[i].num);  
  69.         L[i].start_id = n_node;  
  70.         n_node += L[i].num;         
  71.     }   
  72.     printf("已输入\n");  
  73.    
  74.     Node = new node[n_node];  
  75.     printf("从上往下，输入每层属性名:\n");  
  76.     for (int i = 0; i < n_node; i++){  
  77.         Node[i].child[0] = 0;  
  78.         Node[i].p = 0;  
  79.         Node[i].value = 0;  
  80.         scanf("%s",Node[i].name);  
  81.     }  
  82.     printf("已输入\n");  
  83.     printf("从上往下，输入层与层之间的关系矩阵:\n");  
  84.     for (int i = 0; i < n_level - 1; i++){  
  85.         for (int j = 0; j < L[i].num; j++)  
  86.         for (int k = 0; k < L[i+1].num; k++){  
  87.             int ifConnect;  
  88.             scanf("%d",&ifConnect);  
  89.             if (ifConnect){  
  90.                int cur = L[i].start_id + j;  
  91.                Node[cur].child[0]++;  
  92.                Node[cur].child[Node[cur].child[0]] = L[i+1].start_id + k;  
  93.             }  
  94.         }  
  95.     }  
  96.     printf("已输入\n");  
  97.        
  98.     printf("从上往下，输入成对比较矩阵:\n");  
  99.     for (int i = 0; i < n_level - 1; i++){  
  100.         for (int j = 0; j < L[i].num; j++){  
  101.             int cur = L[i].start_id + j;  
  102.             int size = Node[cur].child[0];  
  103.             Node[cur].comp = new double*[size];  
  104.             for (int k = 0; k < size; k++) Node[cur].comp[k] = new double[size];  
  105.             for (int li = 0; li < size; li++)  
  106.                 for (int lj = 0; lj < size; lj++)  
  107.                     myScanf(&Node[cur].comp[li][lj]);  
  108.         }  
  109.     }  
  110.     printf("已输入\n");  
  111. }  
  112. /* 
  113.  * 程序中止，并输出原因  
  114.  */  
  115. void alert(char* p){  
  116.     printf("%s回车退出\n", p);  
  117.     freopen("CON", "r", stdin);  
  118.     system("pause");  
  119.     exit(0);  
  120. }  
  121. /* 
  122.  * n阶矩阵matrix和w相乘，并归一化w 
  123.  * retDiv为归一化的倍数，返回归一化后的矩阵  
  124.  */  
  125. double* normalize(double** matrix, double* w, int n, double* retDiv){  
  126.     double* ret = new double[n];  
  127.     for (int i = 0; i < n; i++) ret[i] = 0;  
  128.     for (int i = 0; i < n; i++)  
  129.         for (int j = 0; j < n; j++) {  
  130.             ret[i] += matrix[i][j] * w[j];  
  131.         }  
  132.     double sum = 0;  
  133.     for (int i = 0; i < n; i++) sum += ret[i];  
  134.     for (int i = 0; i < n; i++) ret[i]/=sum;  
  135.     *retDiv = sum;  
  136.     return ret;  
  137. }  
  138. /* 
  139.  * 检查节点编号为id的节点的成对比较矩阵是否通过一致性检验  
  140.  */  
  141. bool checkCR(int id){  
  142.     double** matrix = Node[id].comp;  
  143.     int n = Node[id].child[0];  
  144.     double *w = new double[n], *w_new = new double[n];  
  145.     for (int i = 0; i < n; i++) w_new[i] = 1;  
  146.     double eps = 1e-10;  
  147.     double* retDiv = new double;  
  148.     w_new = normalize(matrix, w_new, n, retDiv);  
  149.     while (true){  
  150.           w = w_new;  
  151.           w_new = normalize(matrix, w, n, retDiv);  
  152.           bool flag = true;  
  153.           for (int i = 0; i < n; i++)   
  154.               if (w[i] - w_new[i] > eps || w[i] - w_new[i] < -eps){  
  155.                        flag=false;  
  156.                        break;  
  157.               }  
  158.           if (flag) break;  
  159.     }  
  160.     Node[id].w = w_new;  
  161.     double ans= 0;  
  162.     for (int i = 0; i < n; i++)  
  163.         ans += w_new[i]/w[i];  
  164.     ans = ans * (*retDiv) / n;   
  165.     double CI = (ans - n)/(n-1);  
  166.     Node[id].CI = CI;  
  167.     if (CI < 0.1 * RI[n]) return true;  
  168.     return false;  
  169. }  
  170. /* 
  171.  * 所有单排序权向量的一致性检验  
  172.  */  
  173. void checkSingleMatrix(){  
  174.     for (int i = 0; i < n_level - 1; i++){  
  175.         for (int j = 0; j < L[i].num; j++){  
  176.             int cur = L[i].start_id + j;  
  177.             if (!checkCR(cur)) {  
  178.                printf("第%d层%d号元素<name: %s>的成对比较矩阵无法通过校验,请重新设计",  
  179.                    i, j, Node[cur].name);  
  180.                alert("");  
  181.             }  
  182.                
  183.         }  
  184.     }  
  185. }  
  186. /* 
  187.  * 总排序权向量的一致性检验  
  188.  */  
  189. void checkTotal(){  
  190.     double CR = 0;  
  191.     Node[0].p = 1;  
  192.     /* 
  193.      * 计算最后一层中间层的到达概率，即“重要性” 
  194.     */  
  195.     for (int i = 0; i < n_level - 2; i++){  
  196.         for (int j = 0; j < L[i].num; j++){  
  197.             int cur = L[i].start_id + j;  
  198.             for (int k = 1; k <= Node[cur].child[0]; k++){  
  199.                 int child = Node[cur].child[k];  
  200.                 Node[child].p += Node[cur].p * Node[cur].w[k-1];  
  201.             }  
  202.         }  
  203.     }  
  204.     int cL = n_level - 2;  
  205.     double sumaCI = 0, sumaRI = 0;  
  206.     for (int j = 0; j < L[cL].num; j++){  
  207.         int cur = L[cL].start_id + j;  
  208.         sumaCI += Node[cur].p * Node[cur].CI;  
  209.         sumaRI += Node[cur].p * RI[Node[cur].child[0]];  
  210.     }  
  211.     CR = sumaCI / sumaRI;  
  212.     printf("CR值: %.5lf\n",CR);  
  213.     if (CR >= 0.1){  
  214.         alert("无法通过总排序权向量的一致性检验，请重新设计\n");   
  215.     }  
  216.     printf("检验通过\n");   
  217. };  
  218. /* 
  219.  * 根据经检验后的权重，设计最终方案，比较并选择最优解。  
  220.  */  
  221. void design(){  
  222.     int cL = n_level - 2;  
  223.     for (int j = 0; j < L[cL].num; j++){  
  224.         int cur = L[cL].start_id + j;  
  225.         for (int k = 1; k<= Node[cur].child[0]; k++){  
  226.             int child = Node[cur].child[k];  
  227.             Node[child].value += Node[cur].p * Node[cur].w[k-1];  
  228.         }  
  229.     }  
  230.     cL = n_level - 1;  
  231.     double maxValue = -1e10;  
  232.     int maxPlace = -1;  
  233.     for (int j = 0; j < L[cL].num; j++){  
  234.         int cur = L[cL].start_id + j;  
  235.         if (Node[cur].value > maxValue){  
  236.            maxValue = Node[cur].value;  
  237.            maxPlace = cur;  
  238.         }  
  239.         printf("<%s>: %.5lf  ", Node[cur].name, Node[cur].value);  
  240.     }  
  241.     printf("\n\n");  
  242.     printf("最优方案为<%s>, 权重为<%.5lf>\n", Node[maxPlace].name, Node[maxPlace].value);  
  243. };  
  244. /* 
  245.  * 整个计算过程  
  246.  */  
  247. void calc(){  
  248.     printf("单排序权向量一致性检验\n");   
  249.     checkSingleMatrix();  
  250.     printf("检验通过\n");   
  251.     printf("总排序权向量一致性检验\n");   
  252.     checkTotal();  
  253.     printf("计算方案权值\n");  
  254.     design();  
  255.     freopen("CON", "r", stdin);  
  256.     system("pause");  
  257. }  
  258. int main()  
  259. {  
  260.     freopen("level_input.txt","r",stdin);  
  261.     input();  
  262.     calc();  
  263. }  


输入数据文件level_input.txt

[plain] view plaincopy
  1. 3  
  2.    
  3. 1 5 3  
  4.    
  5. 决策  
  6. 景色 费用 居住 饮食 旅途  
  7. 苏州 杭州 桂林  
  8.    
  9. 1 1 1 1 1  
  10.    
  11. 1 1 1  
  12. 1 1 1  
  13. 1 1 1  
  14. 1 1 1  
  15. 1 1 1  
  16.    
  17. 1 1/2 4 3 3  
  18. 2 1 7 5 5  
  19. 1/4 1/7 1 1/2 1/3  
  20. 1/3 1/5 2 1 1  
  21. 1/3 1/5 3 1 1  
  22.    
  23. 1 2 5  
  24. 1/2 1 2  
  25. 1/5 1/2 1  
  26.    
  27. 1 1/3 1/8  
  28. 3 1 1/3  
  29. 8 3 1  
  30.    
  31. 1 1 3  
  32. 1 1 3  
  33. 1/3 1/3 1  
  34.    
  35. 1 3 4  
  36. 1/3 1 1  
  37. 1/4 1 1  
  38.    
  39. 1 1 1/4  
  40. 1 1 1/4  
  41. 4 4 1  


本文较长，难免会出现各种各样的错误，欢迎评论批评指正，尊重劳动果实，转载请注明ipipblog.net

上一篇：【Android 应用开发】Android 网络编程 API笔记 - java.net 包 权限 地址 套接字 相关类 简介（一）


下一篇：DL之ANN/DNN： 人工神经网络ANN/DNN深度神经网络算法的简介、应用、经典案例之详细攻略