精华内容
下载资源
问答
  • 2021-04-08 14:53:23

    题目:设计一个算法,求出指定节点在给定二叉排序树中的层次
        分析:
            我们可以根据二叉排序树的性质,从根节点一直向下查找,每查找一次,层次便加一

    typedef struct node {
    	int data;
    	node *left, *right;
    }Tree;
    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    
    Tree *create(Tree *T) {//先序创建一颗二叉树
    	int data;
    	printf("请输入当前节点值:data=");
    	scanf("%d", &data);
    	getchar();
    	if (data != -1) {
    		T = (Tree *)malloc(sizeof(Tree));
    		T->data = data;
    		T->left = NULL;
    		T->right = NULL;
    		T->left = create(T->left);
    		T->right = create(T->right);
    	}
    	return T;
    }
    int findLevel(Tree *T, int p) {
    	static int depth = 1;
    	if (T) {
    		if (T->data < p) {
    			findLevel(T->right, p);
    			depth++;
    		}
    		else if(T->data > p){
    			findLevel(T->left, p);
    			depth++;
    		}
    	}
    	return depth;
    }
    int main() {
    	//创建一颗二叉排序树
    	Tree *T = (Tree *)malloc(sizeof(Tree *));
    	T = create(T);
    	int p = 9,depth;//手动指定节点值
    	depth = findLevel(T,p);
    	printf("该节点所在的层次为第%d层",depth);
    	return 0;
    }

      要想赢,就一定不能怕输。不怕输,结果未必能赢。但是怕输,结果则一定是输。

    更多相关内容
  • 基本过程是:对所分析的问题建立层次模型,然后将一个层次的各因素相对于上一层次的各准则(或目标)进行两两比较判断,构造判断矩阵,通过对判断矩阵的计算,进行层次排序和一致性检验,最后进行层次总排序,得
  • 论文研究-层次分析法中排序权数的计算方法.pdf, 本文介绍层次分析法中对于完整及残缺评判矩阵排序权数的几种计算方法以及改进措施,并对多层次综合评判作了一些探讨和分析。
  • 论文研究-多人层次排序下权重向量的算法.pdf,
  • 论文研究-计算层次分析法中排序权值的加速遗传算法.pdf, 为处理 AHP中判断矩阵的一致性问题 ,直接从判断矩阵的定义出发 ,提出用加速遗传算法同时计算 AHP中各要素的排序...
  • 总排序是指每一个判断矩阵各因素针对目标层的相对权重这一权重的计算采用自上而下逐层合成的原则 具体计算如下 Step1 构造判断矩阵计算主指标层M中8个元素对于目标的权重向量 次指标层N中20个元素对于M层的第j个...
  • ![图片说明](https://img-ask.csdn.net/upload/201708/26/1503755196_260855.jpg) (2)中按行求和是什么意思?
  • 针对传统排序算法计算耗时、实时性差的缺点,提出一种可并行的多层次归并排序算法并在FPGA中实现了其并行计算,同时分析了其周期精确的计算时间。结果表明该归并排序算法可以[O(N)]的时间复杂度完成特征点的排序,...
  • 针对进行输电网规划时难以量化各指标主观权重与客观权重的问题,提出了一种将改进层次分析法、基于指标相关性的指标权重确定(CRITIC)法和逼近理想解排序法(TOPSIS)相结合的输电网规划方案评价方法。该方法首先分别...
  • 提出了一个基于层次分类的搜索引擎页面排序算法。该算法通过对页面进行层次化分类进而计算贝面之间相关性,根据相关性的不同,对来自不同页面的外部链接赋予不同的权重,从而更公正、有效地计算页面的PageRank值。...
  • 介绍层次分析法的基本概念,同时也分析了层次分析法权重的计算方法及应用,层次分析法的计算方法有四种方法:几何平均法、算术平均法、特征向量法、最小二乘法,以往的文献利用层次分析法解决实际问题时,都是采用其中的...
  • 层次分析法计算权重

    千次阅读 2020-11-26 11:13:02
    初学者搞的层次分析法,先放代码再放图 import numpy as np import pandas as pd import pymysql import math import time import datetime from sqlalchemy import create_engine class AHP: """ 相关信息的传入...

    初学者搞的层次分析法,先放代码再放图

    import numpy as np
    import pandas as pd
    import pymysql
    import math
    import time
    import datetime
    from sqlalchemy import create_engine
    
    class AHP:
        """
        相关信息的传入和准备
        """
    
        def __init__(self, array):
            ## 记录矩阵相关信息
            self.array = array
            ## 记录矩阵大小
            self.n = array.shape[0]
            # 初始化RI值,用于一致性检验
            self.RI_list = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49, 1.51]
            # 矩阵的特征值和特征向量
            self.eig_val, self.eig_vector = np.linalg.eig(self.array)
            # 矩阵的最大特征值
            self.max_eig_val = np.max(self.eig_val)
            # 矩阵最大特征值对应的特征向量
            self.max_eig_vector = self.eig_vector[:, np.argmax(self.eig_val)].real
            # 矩阵的一致性指标CI
            self.CI_val = (self.max_eig_val - self.n) / (self.n - 1)
            # 矩阵的一致性比例CR
            self.CR_val = self.CI_val / (self.RI_list[self.n - 1])
    
        """
        一致性判断
        """
        def test_consist(self):
            # 打印矩阵的一致性指标CI和一致性比例CR
            print("判断矩阵的CI值为:" + str(self.CI_val))
            print("判断矩阵的CR值为:" + str(self.CR_val))
            # 进行一致性检验判断
            if self.n == 2:  # 当只有两个子因素的情况
                print("仅包含两个子因素,不存在一致性问题")
            else:
                if self.CR_val < 0.1:  # CR值小于0.1,可以通过一致性检验
                    print("判断矩阵的CR值为" + str(self.CR_val) + ",通过一致性检验")
                    return True
                else:  # CR值大于0.1, 一致性检验不通过
                    print("判断矩阵的CR值为" + str(self.CR_val) + "未通过一致性检验")
                    return False
        """
        特征值法求权重
        """
        def cal_weight__by_eigenvalue_method(self):
            # 将矩阵最大特征值对应的特征向量进行归一化处理就得到了权重
            array_weight = self.max_eig_vector / np.sum(self.max_eig_vector)
            # 打印权重向量
            for index in range(len(array_weight)):
                array_weight[index] = round(array_weight[index],2)
            print(array_weight)
            # 返回权重向量的23
            # 值
            return array_weight
    
    
    
    '''
      计算权重
    '''
    RI = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49, 1.51]
    
    #信息准确
    mes = np.array([[1,3,5],
                    [1/3,1,3],
                    [1/5, 1/3, 1]])
    m1 = len(mes)  # 获取指标个数
    n1 = len(mes[0])
    R1 = np.linalg.matrix_rank(mes)  # 求判断矩阵的秩
    V1, D1 = np.linalg.eig(mes)  # 求判断矩阵的特征值和特征向量,V特征值,D特征向量;
    list1 = list(V1)
    B1 = np.max(list1)  # 最大特征值
    index1 = list1.index(B1)
    C1 = D1[:, index1]  # 对应特征向量
    CI1 = (B1 - n1) / (n1 - 1)  # 计算一致性检验指标CI
    CI1 = CI1.real
    CR1 = CI1 / RI[n1]
    CR1 = CR1.real
    if CR1 < 0.10:
        print("信息准确权重:")
        # 特征值法求权重
        mes_weight = AHP(mes).cal_weight__by_eigenvalue_method()
    
    
    #交费行为
    pay = np.array([[1, 1.1, 1.3, 5.3, 5.7, 7],
                    [1 / 1.1, 1, 1.2, 5.2, 5.5, 6.8],
                    [1 / 1.3, 1 / 1.2, 1, 5, 5.4, 6.6],
                    [1 / 5.3, 1 / 5.2, 1 / 5, 1, 1.5, 2.8],
                    [1 / 5.7, 1 / 5.5, 1 / 5.4, 1 / 1.5, 1, 2.5],
                    [1 / 7, 1 / 6.8, 1 / 6.6, 1 / 2.8, 1 / 2.5, 1]])
    m2 = len(pay)  # 获取指标个数
    n2 = len(pay[0])
    R2 = np.linalg.matrix_rank(pay)  # 求判断矩阵的秩
    V2, D2 = np.linalg.eig(pay)  # 求判断矩阵的特征值和特征向量,V特征值,D特征向量;
    list2 = list(V2)
    B2 = np.max(list2)  # 最大特征值
    index2 = list2.index(B2)
    C2 = D2[:, index2]  # 对应特征向量
    CI2 = (B2 - n2) / (n2 - 1)  # 计算一致性检验指标CI
    CI2 = CI2.real
    CR2 = CI2 / RI[n2]
    CR2 = CR2.real
    if CR2 < 0.10:
        print("交费行为权重:")
        # 特征值法求权重
        pay_weight = AHP(pay).cal_weight__by_eigenvalue_method()
    
    #用电行为
    elec = np.array([[1,2,3.5,3.8,5.5,5.9],
                     [1/2,1,3.3,3.5,5.4,5.7],
                     [1/3.5,1/3.3,1,1.5,3.5,3.7],
                     [1/3.8,1/3.5,1/1.5,1,3.2,3.5],
                     [1/5.5,1/5.4,1/3.5,1/3.2,1,1.3],
                     [1/5.9,1/5.7,1/3.7,1/3.5,1/1.3,1]
                     ])
    m3 = len(elec)  # 获取指标个数
    n3 = len(elec[0])
    R3 = np.linalg.matrix_rank(elec)  # 求判断矩阵的秩
    V3, D3 = np.linalg.eig(elec)  # 求判断矩阵的特征值和特征向量,V特征值,D特征向量;
    list3 = list(V3)
    B3 = np.max(list3)  # 最大特征值
    index3 = list3.index(B3)
    C3 = D3[:, index3]  # 对应特征向量
    CI3 = (B3 - n3) / (n3 - 1)  # 计算一致性检验指标CI
    CI3 = CI3.real
    CR3 = CI3 / RI[n3]
    CR3 = CR3.real
    if CR3 < 0.10:
        print("用电行为权重:")
        # 特征值法求权重
        elec_weight = AHP(elec).cal_weight__by_eigenvalue_method()
    
    #准则层判断矩阵
    credit = np.array([[1,3,5],
                    [1/3,1,3],
                    [1/5, 1/3, 1]])
    m1 = len(credit)  # 获取指标个数
    n1 = len(credit[0])
    R1 = np.linalg.matrix_rank(credit)  # 求判断矩阵的秩
    V1, D1 = np.linalg.eig(credit)  # 求判断矩阵的特征值和特征向量,V特征值,D特征向量;
    list1 = list(V1)
    B1 = np.max(list1)  # 最大特征值
    index1 = list1.index(B1)
    C1 = D1[:, index1]  # 对应特征向量
    CI1 = (B1 - n1) / (n1 - 1)  # 计算一致性检验指标CI
    CI1 = CI1.real
    CR1 = CI1 / RI[n1]
    CR1 = CR1.real
    if CR1 < 0.10:
        print("客户信用权重:")
        # 特征值法求权重
        weight = AHP(credit).cal_weight__by_eigenvalue_method()
    
    '''
    连接ads宽表,取出数据,计算信息质量得分、交费行为得分、用电行为得分、总得分
    '''
    
    # python读数据库
    # 连接mysql数据库
    conn = pymysql.connect(
        host='25.212.157.216',
        port=13306,
        user='jingyanyuan',
        password='Jingyanyuan@%458',
        db='jingyanyuan',
        charset='utf8',
        cursorclass=pymysql.cursors.DictCursor)#json格式
    # 创建游标
    cursor = conn.cursor()  # 执行完毕返回的结果默认以元组的形式保存
    # 使用 execute()  方法执行 SQL 查询
    sql = 'select * from mrt_cons_credit_jyy_m'
    cursor.execute(sql)
    data = cursor.fetchall()
    update_sql = 'update mrt_cons_credit_jyy_m set info_ql_sco =(%s),deal_ql_sco =(%s) , elec_mn_sco =(%s), credit_sco =(%s)  where cons_no = (%s)'
    update_data = []
    #循环遍历所有数据
    for index in range(len(data)):
        total_score = 0
        row_data = data[index]
        #基础信息
        cons_no = data['cons_no']
        cons_nm = data['cons_nm']
        cert_typ = data['cert_typ']
        cert_no = data['cert_no']
        elec_typ = data['elec_typ']
        elec_addr = data['elec_addr']
        tel_no = data['tel_no']
        owner_dt = data['owner_dt']
        ls_wechat = data['ls_wechat']
        ls_app = data['is_app']
        mes_len = 18
        '''
            信息准确得分    
        '''
        mes_score = 0
    
        # 基础信息完整性
        count_null = 0
        if (cons_no.strip() == ''):
            count_null += 1
        if (cons_nm.strip() == ''):
            count_null += 1
        if (cert_typ.strip() == ''):
            count_null += 1
        if (cert_no.strip() == ''):
            count_null += 1
        if (elec_typ.strip() == ''):
            count_null += 1
        if (elec_addr.strip() == ''):
            count_null += 1
        if (tel_no.strip() == ''):
            count_null += 1
        if (owner_dt.strip() == ''):
            count_null += 1
        if (count_null == 0):
            mes_score += mes_weight[0] * 100
        elif (count_null == 1):
            mes_score += mes_weight[0] * 75
        elif (count_null == 2):
            mes_score += mes_weight[0] * 50
        elif (count_null >=3 and count_null<mes_len):
            mes_score += mes_weight[0] * 25
        else:
            mes_score += 0
    
        #基础信息准确性
        if(cert_typ==1 and len(cert_no)!=18):
            mes_score += mes_weight[1] * 0
        else:
            mes_score += mes_weight[1] * 100
    
        #附加信息完整性
        if(ls_app==0 and ls_wechat==0):
            mes_score += mes_weight[2] * 0
        elif (ls_app == 1 and  ls_wechat == 1):
            mes_score += mes_weight[2] * 100
        else:
            mes_score += mes_weight[2] * 50
        print("信息准确得分:\n")
        print(mes_score)
    
        '''
            交费行为得分    
        '''
        pay_score = 0
        rcvbl_penalty_sum = data['rcvbl_penalty_sum']
        deal_amt_sum = data['deal_amt_sum']
        deal_channel_Pref = data['deal_channel_Pref']
        deal_channel_kind = data['deal_channel_kind']
    
        # 交费金额
        if (deal_amt_sum >=0 and deal_amt_sum < 87.6):
            pay_score += 0
        elif (deal_amt_sum>= 87.6 and deal_amt_sum < 215):
            pay_score += pay_weight[0] * 25
        elif (deal_amt_sum>=215 and deal_amt_sum < 488):
            pay_score += pay_weight[0] * 50
        elif (deal_amt_sum>=488 and deal_amt_sum < 1360):
            pay_score += pay_weight[0] * 75
        else:
            pay_score += pay_weight[0] * 100
    
        # 累计违约金额占比
        pay_percent = round(rcvbl_penalty_sum/deal_amt_sum,4)
        if(pay_percent == 0):
            pay_score += pay_weight[1] * 100
        elif(pay_score<0.0003):
            pay_score += pay_weight[1] * 75
        elif (pay_score <0.0009):
            pay_score += pay_weight[1] * 50
        elif (pay_score < 0.0023):
            pay_score += pay_weight[1] * 25
        else:
            pay_score += 0
    
        # 累计违约金额
        if (rcvbl_penalty_sum == 0):
            pay_score += pay_weight[2] * 100
        elif (rcvbl_penalty_sum < 1.09):
            pay_score += pay_weight[2] * 75
        elif (rcvbl_penalty_sum < 3.95):
            pay_score += pay_weight[2] * 50
        elif (rcvbl_penalty_sum < 13.6):
            pay_score += pay_weight[2] * 25
        else:
            pay_score += 0
    
        # 交费渠道偏好
        if(deal_channel_Pref == '0203'):
            pay_score += pay_weight[3] * 75
        elif (deal_channel_Pref == '0307' or deal_channel_Pref == '030702'
              or deal_channel_Pref == '0306' or deal_channel_Pref == '011101'):
            pay_score += pay_weight[3] * 100
        else:
            pay_score += pay_weight[3] * 50
    
        # 交费渠道种类
        if(deal_channel_kind >= 3):
            pay_score += pay_weight[4] * 25
        elif (deal_channel_kind  == 2):
            pay_score += pay_weight[4] * 50
        else:
            pay_score += pay_weight[4] * 100
    
        #户龄
        now_date = datetime.datetime.fromtimestamp(time.time())
        owner_dt = datetime.datetime.fromtimestamp(owner_dt)
        dd = (now_date - owner_dt).days / 30
        dd = math.ceil(dd)
        if (dd <70 ):
            pay_score += pay_weight[5] * 25
        elif (dd<133):
            pay_score += pay_weight[4] * 50
        elif (dd <175):
            pay_score += pay_weight[4] * 75
        else:
            pay_score += pay_weight[4] * 100
    
        print("交费行为得分:\n")
        print(pay_score)
    
        elec_score = 0
    
        '''
           用电行为得分    
        '''
        violate_kind = data['violate_kind']
        violate_num = data['violate_num']
        violate_elecqt = data['violate_elecqt']
        steal_kind = data['steal_kind']
        steal_num = data['steal_num']
        steal_elecqt = data['steal_elecqt']
    
        # 违法次数
        if (steal_num == 0):
            elec_score += elec_weight[0] * 100
        elif (steal_num == 1):
            elec_score += elec_weight[0] * 10
        elif (steal_num == 2):
            elec_score += elec_weight[0] * 10
        else:
            elec_score += 0
    
        # 违规次数
        if (violate_num == 0):
            elec_score += elec_weight[1] * 100
        elif (violate_num == 1):
            elec_score += elec_weight[1] * 10
        elif (violate_num == 2):
            elec_score += elec_weight[1] * 10
        else:
            elec_score += 0
    
        # 违法追补电量
        if (steal_elecqt == 0):
            elec_score += elec_weight[2] * 100
        elif (steal_elecqt>0):
            elec_score += 0
    
        # 违规追补电量
        if (violate_elecqt == 0):
            elec_score += elec_weight[3] * 100
        elif (violate_elecqt > 0):
            elec_score += 0
    
        # 违法窃电种类
        if (steal_kind == 0):
            elec_score += elec_weight[4] * 100
        elif (steal_kind == 1):
            elec_score += elec_weight[4] * 10
        elif (steal_kind == 2):
            elec_score += elec_weight[4] * 10
        else:
            elec_score += 0
    
        #违规种类
        if (violate_kind == 0):
            elec_score += elec_weight[4] * 100
        elif (violate_kind == 1):
            elec_score += elec_weight[4] * 10
        elif (violate_kind == 2):
            elec_score += elec_weight[4] * 10
        else:
            elec_score += 0
        print("用户行为得分:\n")
        print(elec_score)
    
        #计算总分
        total_score = weight[0] * mes_score + weight[1] * pay_score + weight[2] * elec_score
    
        #赋值分数
        tmp_update_data = [mes_score,pay_score,elec_score,total_score,cons_no]
        update_data.append(tmp_update_data)
    
    
    # 批量更新
    try:
        res = cursor.executemany(update_sql, update_data)
        print(res)
        conn.commit()
    except Exception as e:
        print(e)
        conn.rollback()
    finally:
        # 关闭数据库
        cursor.close()
        conn.close()
    
    
    

    在这里插入图片描述

    展开全文
  • 层次分析法

    2019-05-23 22:07:21
    1.建立层次分析结构并构造准则层对目标层判断矩阵A 2.求最大特征值并根据最大特征值进行判断矩阵的一致性检验 3.由最大特征值求判断矩阵A的特征矩阵,经标准化后得到判断矩阵A的...5.层次总排序,得到总排序权值...

    在这里插入图片描述

    1.建立层次分析结构并构造准则层对目标层判断矩阵A
    2.求最大特征值并根据最大特征值进行判断矩阵的一致性检验
    3.由最大特征值求判断矩阵A的特征矩阵,经标准化后得到判断矩阵A的权值矩阵
    比较权值矩阵的各值得到准则层权值,既可以比较准则层的重要程度。
    4.方案层的单排序权值也一样,只是把准则层对目标层判断矩阵A换成了方案层对准则层的判断矩阵C,一样可以得到重要程度。
    5.层次总排序,得到总排序权值。即为
    在这里插入图片描述

    在上一程序中可依次得到准则层单排序权值B=[b1 b2… bn];
    方案层单排序权值C1=[c1 c2…,cn];
    C2=[m1 m2…,mn];
    Cn=[k1 k2…,kn];
    则总排序权值:W1=sum(B.*C1);
    W2=sum(B.*C2);
    W3=sum(B.*C3);

    Matlab程序:
    % %AHP权重计算MATLAB程序
    % %数据读入
    clc;
    clear all;
    A=[1 1/5 3;5 1 7;1/3 1/7 1];
    % %一致性检验和权向量计算
    [n,n]=size(A);
    [v,d]=eig(A);
    r=d(1,1);
    CI=(r-n)/(n-1);
    RI=[0 0 0.58 0.90 1.12 1.24 1.32 1.41 1.45 1.49 1.52 1.54 1.56 1.58 1.59];
    CR=CI/RI(n);
    if(CR<0.10)
    CR_RESULT=‘通过’;
    else
    CR_RESULT=‘不通过’;
    end
    % %权向量计算
    w=v(:,1)/sum(v(:,1));
    w=w’;
    % %结果给出
    disp(‘该判断矩阵权向量计算报告:’);
    disp([‘一致性指标:’ num2str(CI)]);
    disp([‘一致性比例:’ num2str(CR)]);
    disp([‘一致性检验结果:’ CR_RESULT]);
    disp([‘特征值:’ num2str®]);
    disp([‘特征向量:’ num2str(w)]);

    计算总排序权值的程序:

    参考网站:https://blog.csdn.net/qq_23860475/article/details/80660841

    https://www.cnblogs.com/buzhizhitong/p/5844139.html

    展开全文
  • AHP,即层次分析法(Analytic Hierarchy Process,AHP)是一种系统化的、层次化的多目标综合评价方法。在评价对象的待评价属性复杂多样,结构各异,难以量化的情况下AHP层次分析法也能发挥作用。

    目录

    1.层次分析法原理介绍

    2.层次分析法建模步骤

    3.案例分析

    3.1 题目简述

    3.2 确定评价指标,建立层次关系

    3.3 构造判断矩阵

    3.3.1 标度定义

    3.3.2 构造判断矩阵

     3.4 一致性检验

    3.5 层次总排序

    4.代码实现


    1.层次分析法原理介绍

            关于层次分析法的具体原理即详细的步骤以及有很多人发布,可自行搜索查看,以下链接为个人认为较好的两篇:数学建模方法——层次分析法(AHP)_Learning-Deep-CSDN博客_层次分析法列向量归一化计算0. 层次分析法简介层次分析法(Analytic Hierarchy Process,简称AHP)主要是对于定性的决策问题进行定量化分析的方法。举个例子,在日常生活中,我们经常需要进行感性的判断,比如报高考志愿,感觉清华北大都很好,到底要报哪个;再比如去市场买菜,到底是买青椒做青椒炒鸡蛋,还是买黄瓜做黄瓜炒鸡蛋;再比如想去出游,到底是去公园A还是公园B。上面提到的这些问题,都是决策,也叫做评价类...https://blog.csdn.net/limiyudianzi/article/details/103389880?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164386596716780261988153%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164386596716780261988153&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-103389880.pc_search_insert_es_download&utm_term=AHP&spm=1018.2226.3001.4187

    【AHP】层次分析法 | 过程解读 案例实践_Fxtack的博客-CSDN博客_ahp分析法完整案例AHP 层次分析法一. AHP 层次分析法介绍AHP 层次分析法简介AHP,即层次分析法(Analytic Hierarchy Process,AHP)是一种系统化的、层次化的多目标综合评价方法。在评价对象的待评价属性复杂多样,结构各异,难以量化的情况下AHP层次分析法也能发挥作用。AHP 基本思想 [1]AHP 把复杂的问题分解为各个组成因素,又将这些因素按支配关系分组形成地递阶层次结构。通过两两比较的方式确定方式确定层次中诸因素的相对重要性。然后综合有人员的判断,确定备选方案相对重要https://blog.csdn.net/weixin_43095238/article/details/108055579?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164386596716780261988153%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164386596716780261988153&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_click~default-2-108055579.pc_search_insert_es_download&utm_term=AHP&spm=1018.2226.3001.4187

    2.层次分析法建模步骤

    3.案例分析

    3.1 题目简述

            假定现需要购置一批冰箱,由于市场上冰箱种类参差不齐,其性能及性价比也存在很大差异,现有一批冰箱待选择,请考虑冰箱的容积、功耗、外观、噪声、寿命、价格、保修时间等因素,建立模型,确定性价比最高的购买方案。

    量化后冰箱参数:

    以冰箱A为基准,若该项性能优于A则其值加1,且每优一级都加1,反之亦然。

    容积功耗外观噪声寿命价格保修时间
    A5555555
    B6838797
    C24828510

    3.2 确定评价指标,建立层次关系

    3.3 构造判断矩阵

    3.3.1 标度定义

    标度含义
    1两个要素相比,重要性相同
    3两要素相比,前者比后者稍微重要或有优势
    5两要素相比,前者比后者比较重要或有优势
    7两要素相比,前者比后者十分重要或有优势
    9两要素相比,前者比后者绝对重要或有优势
    2,4,6,8为上述标度之间的中间值

    若要描述后者与前者比较,则用倒数为标度。例如 1/3 描述的是,后者比前者稍微重要。 

    3.3.2 构造判断矩阵

    属性容积功耗外观噪声寿命价格保修时间
    容积

    1

    3

    2

    1/2

    1/3

    1/6

    1/2

    功耗

    1/3

    1

    5

    1

    1/3

    1/2

    1/2

    外观

    1/2

    1/5

    1

    1/3

    1/3

    1/4

    1/3

    噪声

    2

    1

    3

    1

    1/3

    1/3

    1/3

    寿命

    3

    3

    3

    3

    1

    1/2

    1/2

    价格

    6

    2

    4

    3

    1

    1

    3

    保修时间

    2

    2

    3

    3

    2

    1/3

    1

     3.4 一致性检验

    具体的计算方法见推荐阅读的两篇文章。

    经过计算得到C.R=0,025<0.1,故一致性检验成功。

     得到七种属性的权值如下:

    属性容积功耗外观噪声寿命价格保修时间
    权值0.090.100.050.100.180.290.19

    3.5 层次总排序

    属性容积功耗外观噪声寿命价格保修时间评分
    权值0.090.100.050.100.180.290.19
    A55555555
    B68387977.49
    C248285105.97

     由此可见评分:B>C>A。故冰箱B对顾客来说性价比最高。

    4.代码实现

    package AHP;
    
    import java.util.Scanner;
    
    public class AHP {
    	public static void main(String[] args) {
    		System.out.println("输入矩阵阶数:");
    		Scanner scanner = new Scanner(System.in);
    		int n = scanner.nextInt();
    		System.out.println("按行输入:");
    		double d[][] = new double[n][n];
    		double temp[][] = new double[n][n];
    		for (int i = 0; i < n; i++) { 
    			for (int j = 0; j < n; j++) {
    				double sToD = SToD(scanner.next());
    				d[i][j] = sToD;
    				temp[i][j] = sToD;
    			}
    		}
    
    		System.out.println("以下是判断矩阵");
    		// 得到判断矩阵
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				System.out.printf("%.2f\t", d[i][j]);
    			}
    			System.out.println();
    		}
     
    		// 1.对判断矩阵进行求和
    		System.out.println("列相加结果w1");
     
    		double w1[] = new double[n];
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				w1[i] = w1[i] + d[j][i];
    			}
    			System.out.printf("%.2f\t", w1[i]);
    		}
     
    		// 2.相除
    		System.out.println();
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				d[i][j] = d[i][j] / w1[j];
    			}
    		}
    		System.out.println("和积法第一步求出的结果d(即对列向量归一化):");
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				System.out.printf("%.2f\t", d[i][j]);
    			}
    			System.out.println();
    		}
     
    		System.out.println("对第一步求出的结果进行 行相加");
     
    		System.out.println("行相加结果w2:");
     
    		double w2[] = new double[n];
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				w2[i] = w2[i] + d[i][j];
    			}
    			System.out.printf("\t%.2f\n", w2[i]);
    		}
     
    		System.out.println("特征向量求解第一步 : 将上面的行相加的所有结果相加sum:");
    		double sum = 0.0;
    		for (int i = 0; i < n; i++) {
    			sum += w2[i];
    		}
    		System.out.printf("结果为sum = \t%.2f\n", sum);
     
    		System.out.println("将行结果与 sum 相除 得出结果为w3:  ");
    		double w3[] = new double[n];
    		for (int i = 0; i < n; i++) {
    			w3[i] = w2[i] / sum;
    			System.out.printf("\t%.2f\n", w3[i]);
    		}
     
    		System.out.println();
    		System.out.println("************************************************");
    		System.out.println("用和积法计算其最大特征向量为(即权重):W = ");
    		// 以下是校验
    		System.out.printf("(");
    		for (int i = 0; i < n; i++) {
    			System.out.printf("%.2f ,", w3[i]);
    		}
    		System.out.printf(")");
     
    		System.out.print("\nBW(w4) = ");//BW即行相加结果
    		double w4[] = new double[n];
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				w4[i] = w4[i] + temp[i][j] * w3[j];
    			}
    			System.out.printf("%.5f \t", w4[i]);
    		}
    		System.out.println("\n----------------------------------------");
    		double sum2 = 0.0;
    		for (int i = 0; i < n; i++) {
    			sum2 = sum2 + w4[i];
    		}
    		System.out.printf("得到最大特征值sum2:\t %.2f\n", sum2);
    		System.out.println("************************************************");
    		System.out.println("最大的特征向量为 :  ");
     
    		double result = 0.0;
    		for (int i = 0; i < n; i++) {
    			result = result + w4[i] / (6 * w3[i]);
    		}
    		System.out.printf(" %.2f \n", result);
     
    		System.out.println("\n判断矩阵一致性指标C.I.(Consistency Index)");
    		double CI = (result - n) / (n - 1);
    		System.out.printf(" %.2f \n", CI);
     
    		System.out.println("随机一致性比率C.R.(Consistency Ratio)");
     
    		/*
    		 * 
    		 n  1  2  3  	4  		5	  6	  7		  8		 9	  10	  11
    		RI  0  0  0.58  0.90  1.12  1.24  1.36  1.41  1.45  1.49  1.51 
    		一般,当一致性比率 <0.1 时
    		的不一致程度在容许范围之内,可用其归一化特征向量
    		作为权向量,否则要重新构造成对比较矩阵,对  加
    		以调整
    		 */
    		double RI = 0.0;
    		switch (n) {
    		case 0:
    			RI=0;
    			break;
    		case 1:
    			RI=0;
    			break;
    		case 2:
    			RI=0;
    			break;
    		case 3:
    			RI=0.58;
    			break;
    		case 4:
    			RI=0.90;
    			break;
    		case 5:
    			RI=1.12;
    			break;
    		case 6:
    			RI=1.24;
    			break;
    		case 7:
    			RI=1.36;
    			break;
     
    		default:
    			break;
    		}
    		double CR=CI / RI;
    		if(CR<0.1) {
    			System.out.printf("一致性检验成功!  C.R =  %.2f \n", CR);
    		}
    		else
    			System.out.printf("一致性检验失败!  C.R =  %.2f \n", CR);
    		
    		
    		scanner.close();
    	}
     
    	public static double SToD(String s) {
    		String[] p = s.split("/");
    		if (p.length > 1) {
    			return Double.parseDouble(p[0]) / Double.parseDouble(p[1]);
    		}
    		return Double.parseDouble(s);
    	}
    }
    
    

    展开全文
  • 通过"标度变换"把不具"可加性"的比例标度转化为评分标度,利用评分标度的"可加性"可计算比较对象的得分、并按得分率对比较对象排序。与已有单准则排序方法的实质性区别是,勿需进行一致性检验。
  • 数学建模之层次分析法的源程序,输入成对比较矩阵可以得到相应的权重值。层次分析法是数学建模的基础方法,也是比较简单易懂易于操作的。程序具有通用性。几乎只要是层次分析法,给出矩阵就可计算
  • 如何实现按照计算后的结果排序

    千次阅读 2018-10-23 21:49:48
    在做分组报表统计时,我们经常会被要求按照数据升序或降序排序。在 group 函数的参数中,我们可以指定分组后对组的排序表达式,这样报表展现时能够直接根据该表达式进行排序了。我们先来看一个简单的例子,如下图所...
  • 层次分析与一致性检验

    万次阅读 多人点赞 2020-12-20 17:19:25
    目录1、层次分析法的基本步骤1.1、建立层次结构模型1.2、构造判断(成对比较)矩阵1.3、层次排序及一致性检验1.4、 层次总排序及其一致性检验2、总结:层次分析法的4步3、实例:去哪儿旅游5、为什么层次分析法要进行...
  • AHP (Analytic Hierarchy Process)层次分析法是美国运筹学家T. L. Saaty教授于二十世纪70年代提出的一种实用的多方案或多目标的决策方法,是一种定性与定量相结合的决策分析方法。常被运用于多目标、多准则、多要素...
  • 层次分析法是指将一个复杂的多目标决策问题作为一个系统,将目标分解为多个目标或准则,进而分解为多指标的若干层次,通过定性指标模糊量化方法算出层次排序总排序,以作为目标、多方案优化决策的系统方法。...
  • 数学建模:层次分析法实例以及代码

    万次阅读 多人点赞 2020-11-22 22:06:09
    层次排序计算权向量)与检验(一致性检验)计算权向量一致性检验5.层次总排序(组合权向量)与检验(一致性检验)6.结果分析7.层次分析法的优缺点层次分析法的代码实现(matlab) 层次分析法的思想 层次分析法的...
  • 层次分析法综合定性分析与定量分析将复杂的问题用一个逻辑有序的递阶层次结构表示出来,通过经验判断对决策方案的优劣进行排序,建立层次结构模型、构造判断矩阵、层次排序及一致性检验、层次总排序及一致性检验是其...
  • (4)计算各层元素对系统目标的合成权重,进行总排序,以确定递阶结构图中最底层各个元素的目标中的重要程度。 2.熵值法 (1)选取5个省市,16个指标,则表示第i个省市的第j个指标的数值。(i=1,2…,5; j=1,2,…,16...
  • 快速排序的思想是在数组[p,r]中选择一个分区点q,将数组一分为2,同时将小于分区点的数值的放到分区点左侧[p,q-1],大于分区点的数值的放到分区点右侧[q+1,r],重复这个过程。 快速排序也是用到了分治思想和递归实现...
  • 该算法基于通信强度排序方法实现通信社区的有效检出,基于通信密度分布生成高分辨率层次嵌套树,通过距离矢量修剪嵌套树,实现社区稳定检测和层次结构分析同时降低计算复杂度。该算法使用真实网络数据进行了有效验证...
  • 层次分析法(AHP).py

    2019-05-16 11:34:42
    层次分析法是指将一个复杂的多目标决策问题作为一个系统,将目标分解为多个目标或准则,进而分解为多指标(或准则、约束)的若干层次,通过定性指标模糊量化方法算出层次排序(权数)和总排序,以作为目标(多指标...
  • 计算二叉树中指定结点所在的层次

    千次阅读 2020-06-17 16:38:20
    Description 设二叉树的存储结构为二叉链表。在二叉链表中的每个结点由三部分组成:左孩子指针、右孩子指针和结点数据,...返回指定结点所在的层次,如果没找到该结点返回0。 Sample Input ABD^^CEF^ C Sample Output 2
  • (1)用于分区排序 (2)动态Group By (3)Top N (4)累计计算 (5)层次查询 Hive分析窗口函数(一) SUM,AVG,MIN,MAX Hive中提供了越来越多的分析函数,用于完成负责的统计分析。抽时间将所有的分析窗口函数理一...
  • 针对王行庄煤矿二1煤层有无瓦斯突出问题,...进行层次排序层次总排序及一致性检验,找出最危险指标确定其突出危险性,为煤矿开采中瓦斯治理提出可行性建议和措施,对辨识瓦斯事故危险源进行安全现状评价提供合理途径。
  • 如何设计并行排序算法? 在并行计算的工作中,将每一个参与的电脑当作一个节点,节点通常是比较廉价的,可通过增加节点来提高效率。分为以下三个步骤及待解决问题: 将数据拆分到每个节点上(如何拆分,禁止拆分...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,309
精华内容 41,723
关键字:

层次总排序如何计算

友情链接: pqdg.rar