精华内容
下载资源
问答
  • 8-PuzzleAI 一个基于A *启发式算法程序来解决8难题
  • a*启发式搜索算法的matlab仿真程序 a*启发式搜索算法的matlab仿真程序 a*启发式搜索算法的matlab仿真程序 a*启发式搜索算法的matlab仿真程序
  • 启发式算法的讲解,程序(最终版).周吕文
  • 创造矩阵(多维数组)Python numpy 提取矩阵的某一行或某一列https://blog.csdn.net/luoganttcc/article/details/74080768删除矩阵:https://www.jb51.net/article/139764.htmnumpy中的delete删除数组整行和整列的实例...

    创造矩阵(多维数组)

    Python numpy 提取矩阵的某一行或某一列

    https://blog.csdn.net/luoganttcc/article/details/74080768

    删除矩阵:https://www.jb51.net/article/139764.htm

    numpy中的delete删除数组整行和整列的实例

    1.删除一列

    >>> dataset=[[1,2,3],[2,3,4],[4,5,6]]

    >>> import numpy as np

    >>> dataset = np.delete(dataset, -1, axis=1)

    >>> dataset

    array([[1, 2],

    [2, 3],

    [4, 5]])

    2.删除多列

    arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

    np.delete(arr, [1,2], axis=1)

    array([[ 1, 4],

    [ 5, 8],

    [ 9, 12]])

    删除列:

    1.删除第i行和多行操作

    x = numpy.delete(x,i, axis = 0)

    矩阵中元素的定位:

    Python扩展库numpy中where()函数的三种用法

    https://blog.csdn.net/oh5W6HinUg43JvRhhB/article/details/80796594

    dd0max=np.where(list_dd0==np.max(list_dd0)) #0最多的是哪一列

    展开全文
  • 第4讲 多资源车间调度优先分配启发式算法 1 4.1 多资源车间调度概述 1 4.2 优先分配Giffler Thompson启发式算法及其流程 3 4.3 优先分配Giffler Thompson启发式算法Matlab实现 6 4.3.1 数据结构设计 6 4.3.2 Matlab...
  • 启发式算法 Heuristic

    2019-10-02 22:12:38
    Heuristic :  【科斯林】  a heuristic computer program uses rules based on previous experience in order to solve a problem , rather than using a ... 一个启发式的计算机程序使用基于先前经验的规则去...

      Heuristic :

      【科斯林】

      a heuristic computer program uses rules based on previous experience in order to solve a problem , rather than using a mathematical procedure.

      一个启发式的计算机程序使用基于先前经验的规则去解决问题,而不是使用一个数学化的步骤。

      a heuristic method of learning involves discovery and problem solving , using reasoning and past experience.

      一个启发式的方法涉及到探索和问题解决,使用推理和过去的经验。

      【牛津】

      enabling a person to discover or learn something for themselves

      使一个人能够为自己探索或学习一些东西 

      【朗文】

      the use of experience and practical efforts to find answers to questions or to improve performance .

      使用经验和实际的努力去寻找问题的答案或者是对表现的提升。

    ---------------------------------------------------------------------------------------------------------------------------------

      综上,通过对启发式Heuristic这个名词的英文释意来看,启发式算法的两个要点:经验的使用和探索。这两者应当是相辅相成的,通过对自身经验的使用而后再去对一些未知的领域、空间进行探索,从而完善该算法。

      熟悉的领域----基于经验                   未知的领域----探索

      通过探索,将未知变为经验。

    ---------------------------------------------------------------------------------------------------------------------------------

    启发式算法的分类:

      1.依据是否属于自然启发的算法:譬如遗传算法、蚁群算法这些从自然中得到灵感的算法属于自然启发类算法;反之,禁忌搜索、局部搜索就属于非自然启发类算法。当面对最近出现的一些杂交算法时,不容易给该算法分类。

      2.基于人口的搜索和单点搜索:利用同一时间启发式算法使用的解的数量来分类。那些一次只能工作于一个解的算法被称为轨迹的方法。

      3.动态或者是静态算法;

      4.单一或多邻居结构;

      5.使用记忆或不使用记忆;

    ---------------------------------------------------------------------------------------------------------------------------------

    Trajectory Methods              轨迹的方法

      1.basic local search : iterative improvement            基本的局部搜索:迭代提升         【类似于抽样的获取最优?】

      基本的局部搜索也被称为迭代提升,因为每一次只有当当前迭代的解比当前解更好,才会发生转移。

      在临近解中进行迭代,使目标函数逐步优化,直至不能再被优化为止。

      局部搜索是指能够无穷接近最优解的能力,全局收敛力是指能够找到全局最优解所在位置的能力。

    ---------局部搜索算法和初始点的选取有很重要的联系。

      随机选取一定数量的初始点,对每个初始点找到其最优解。而后从这些所有的随机选择的初始点中的最优解中找到最优。

      局部最优,有可能就是全局最优。但是局部最优是否是全局最优是没有什么具体的保证的,也是无法被证明的。

      局部搜索算法的五大要素:

      ·目标函数:用来判断解的优劣

      ·邻域的定义:依据不同的问题,有着不同的邻域定义

      ·初始解的产生规则

      ·新的解的产生规则和接受规则

      ·搜索终止的条件

      2.simulated annealing   模拟退火

      模拟退火的原理:我们将热力学的理论套用到统计学上,将搜寻空间内每一点想像成空气内的分子;分子的能量,就是它本身的动能;而搜寻空间内的每一点,也像空气分子一样带有“能量”,以表示该点对命题的合适程度。算法先以搜寻空间内一个任意点作起始:每一步先选择一个“邻居”,然后再计算从现有位置到达“邻居”的概率。可以证明,模拟退火算法所得解依概率收敛到全局最优解。

      模拟退火过程中温度逐渐降低,同时移动的概率也逐渐降低,从而保证了算法是趋于稳定的。模拟退火选择是随机的移动,有一定概率的跳出局部最优解,找到全局最优;也有一定的概率从全局最优解跳出。

      The fundamental idea is to allow moves resulting in solutions of worse quality than the current solution in order to escape from local minma.The probablity of doing such a move is decreased during the search.

      模拟退火的几大要点:

      ·初始解的寻找

      ·冷却规则 the choice of an apporiate cooling chedule is crucial for the performance of the algorithm.

      ·uphill move的概率和两个解之间目标函数的差值和温度这两个变量相关

      ·温度 temperature should be adapted to the particular problem instance.

      

      3.禁忌搜索 tabu search

      TS explicitly uses the history of the search ,both to escape from local minma and to implement an explorative strategy.

      简单禁忌搜索的算法流程:

      s  <-  GenerateInitialSolution()

      TabuList <- 空集

      while termination conditions not met do

        s <- ChooseBestOf( N(s)\TabuList )

        Update(TabuList)

      endwhile 

     

       禁忌列表的使用阻止从最近访问的解中返回,因此它阻止了死循环的出现并且迫使搜索接受uphill moves【这个和模拟退火中的那个一样】。禁忌列表的长度控制着搜索过程中的记忆。禁忌列表的长度越短,搜索将会注重于在较小的区域内进行搜索;相反,禁忌列表的长度越长,将会趋使搜索进程探索更大的范围。

      However ,the implementation of short term memory as a list that contains complete solutions is not practical ,because managing a list of solutions is highly ineffecient.Therefore , instead of the solutions themselves , solution attributes are stored.

      在禁忌列表中存储解的一些属性而非解本身,相对来说是更加的高效。但是这个导致了一些信息的丢失,比如禁止一个属性值有可能被禁止的不仅仅是一个解,这样就有可能会将那些有着高质量的解排除在外。为了克服这个问题,aspiration criteria 【蔑视规则】被定义允许那些已经存在于禁忌列表中的解被包括到允许解的集合中。

     

      4.探索性的局部搜索方法

      4.1 greedy randmized adaptive search procedure 贪婪的随机适应搜索步骤

      GRASP 是一个迭代的步骤,由两部分组成:解的建设和解的提升【solution construction and solution improvement】。

      第一阶段,解的建设机制有两个主要的特点:动态的启发式建设和随机。假设一个解s是由一个集合的子集元素构成,这个解s一步一步的每次添加一个解逐步构成。下一个元素的选择是通过从候选列表中随机选出。候选列表中的元素按照一定的启发式规则进行排序,即判断该元素插入当前的部分解是否有效,利用一个函数给出这种有效程度的模拟,利用函数的返回值的大小进行排序。

      候选表中存储的是α个解,取决于该启发式算法对偏差的控制能力。当α=1,也就是说智能是最好的解才会被加入到候选表中,也就等价于一个贪婪的启发式算法;当α=n时,解的建设将会完全随机。因此,α的大小是一个影响搜索空间取样的参数【critical parameter】

      第二阶段,解的提升,就是一个局部搜索算法。

      如果满足下列两个条件,GRASP算法就能够时很高效的:

      ·解的建设机制在搜索空间中最令人信服的解中取样

      ·通过建设性的启发式建设的解属于不同局部最小解的吸引盆地【basins of attraction of different locally minimal solutions】

      

      4.2 variable neighborhood search 可变邻居搜索

      动态改变邻居的结构。 The algorithm is very general and  many degrees of freedom exist for designing variants and particulat instantiations.

      VNS的主循环由三个阶段组成:shaking 【抖动】、local search  和  move。

      shaking        ------当前解的第k个邻居被随机选中  --> 得到 s*

      local search ------从被选择的邻居开始作为局部搜索的起点    -->得到s**

      move            ------比较s**和s【函数来比较判断取舍】,选择最优者然后move

      这三个阶段,循环直至遇到终止条件。

      

      4.3领导的局部搜索 guided local search          the features of the solution that guide the local search

      dynamically change the objective function---- 动态的改变目标函数

      The basic GLS is to help the search to gradually move from local minima by chaging the search landscape.The mechanism used by the GLS is based on the solution features , which may be kind of properties or characteristics that can be used to discreminate between solutions.

      特征 、每个特征再给分配一定的权重。从而达到动态改变目标函数的目的。

      f* = f + λ * Σ pi * Ii(s)                   if feature i is present in solution s   Ii(s) =1   else  Ii(s)=0

      pi  are called penalty parameters and λ is called the regularization parameter.

      pi weight the importance of the features ; the regularization parameter balances the relevance of features with respect to the orginal objective function.

     

      4.4 iterated local search        迭代局部搜索   ----最具代表性的探索性策略

      perturbation ----- 对局部搜索得到的局部最优解的忧虑

      当这个忧虑太弱,依旧是无法逃离局部最优的困扰;太强,则会让这个算法表现的和一个随机重新开始的局部搜索算法一样。

      在得到一个局部最优的时候,“思考一下”是否应该选择该局部最优解作为最终的全局最优解---忧虑。忧虑的时候,再利用局部搜索得到一个忧虑后的解,判断这个解和原先的解的好坏决定选择哪个。

     

      基于种群的方法   population-based methods 

      5.1 进化计算 evolutionary computation 

      

     

    转载于:https://www.cnblogs.com/dreammaker-K/p/8830433.html

    展开全文
  • 在石油储层管理中,油井布置的实质是开发和维持储层压力,以实现最大的... 这项研究的结果表明,与仅考虑算法和黑油模拟器的综合效果的其他方案相比,使用工程判断和应用黑油模拟器的算法进行油井布置可以提高产量。
  • 入口坐标和出口坐标分别为(startx,starty)和(endx,eny),每一个坐标点有两种可能:0或1,其中0表示该位置允许通过,1表示该位置不允许通过。以寻路问题为例实现A*算法的求解程序,设计两种不同的估价函数。
  • 启发式算法给Gurobi 输入初始解

    千次阅读 2017-08-16 21:52:19
    今天看论文,提到一种方法,使用启发式算法生成解当做初始解给Gurobi求解。这样的结合求解可以提高求解效率。   主要用到Yalmip 中的 assign 以及usex()命令。   例如: x = sdpvar(1,1); assign(x,pi); ...

    今天看论文,提到一种方法,使用启发式算法生成解当做初始解给Gurobi求解。这样的结合求解可以提高求解效率。

     

    主要用到Yalmip 中的 assign 以及usex()命令。

     

    例如:

    x = sdpvar(1,1);

    assign(x,pi);

    optimize([sin(x)^2 <= .1],x,sdpsettings('usex0',1));

     

    我添加的程序片段如下:

    aa=[     0     1 1 1 1 1 1 1 1 1 1 1
       NaN     0     1 1 1 1 1 1 1 1 1 1
       NaN   NaN     0     1    1 1 1 1 1 1 1 1
       NaN   NaN   NaN     0     1 1     1 1 1 1 1 1
       NaN   NaN   NaN   NaN     0     1 1 1 1     1     1     1
       NaN   NaN   NaN   NaN   NaN     0     1     1 1     1     1     1
       NaN   NaN   NaN   NaN   NaN   NaN     0     1 1 1 1 1
       NaN   NaN   NaN   NaN   NaN   NaN   NaN     0    1   1     1     1
       NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN     0     1     1     1
       NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN     0     1     1
       NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN     0     1
       NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN   NaN     0]; %启发式算法的解,作为Gurobi的初始解。


     assign(a,aa);  %把aa的值赋给变量a.
    ops = sdpsettings('solver','gurobi','usex0',1,'gurobi.TimeLimit',10); %用命令usex()的值为零提示yalmip识别

     

    没有使用启发式算法生成初始解的结果:Explored 17397 nodes (390282 simplex iterations) in 8.74 seconds

    使用启发式算法生成初始解的结果:Explored 7552 nodes (199913 simplex iterations) in 4.71 seconds

    可以看出求解时间,搜索nodes 和 Simplex iterations 得到大规模的降低,提高了求解效率。这是一个好方法,以后可以用到。另外Yalmip中有很多有意思的操作,自己要好好摸索,及时总结。

    展开全文
  • 多目标启发式算法python实现 1. MODA-多目标差分进化算法 基于快速非支配排序算法和拥挤度。 算法主程序 def MODE(nIter, nChr, nPop, F, Cr, func, lb, rb): """多目标差分进化算法主程序 Params: nIter: 迭代...

    1. MODA-多目标差分进化算法

    基于快速非支配排序算法和拥挤度。

    算法主程序

    def MODE(nIter, nChr, nPop, F, Cr, func, lb, rb):
        """多目标差分进化算法主程序 
        Params:
            nIter: 迭代次数
            nPop: 种群规模 
            F: 缩放因子 
            Cr: 交叉概率 
            func:优化函数 
            lb: 自变量下界 
            rb:自变量上界 
        Return:
            paretoPops: 帕累托解集 
            paretoFits: 对应的适应度 
        """
        # 生成初始种群 
        parPops = initPop(nChr, nPop, lb, rb) 
        parFits = fitness(parPops, func) 
    
        # 开始迭代  
        iter = 1 
        while iter <= nIter:
            # 进度条 
            print("【进度】【{0:20s}】【正在进行{1}代...】【共{2}代】".\
                format('▋'*int(iter/nIter*20), iter, nIter), end='\r')
    
            mutantPops = mutate(parPops, F, lb, rb)  # 产生变异向量 
            trialPops = crossover(parPops, mutantPops, Cr)  # 产生实验向量 
            trialFits = fitness(trialPops, func)  # 重新计算适应度 
    
            pops = np.concatenate((parPops, trialPops), axis=0)  # 合并成新的种群
            fits = np.concatenate((parFits, trialFits), axis=0) 
            ranks = nonDominationSort(pops, fits)  # 非支配排序 
            distances = crowdingDistanceSort(pops, fits, ranks)  # 计算拥挤度 
    
            parPops, parFits = select1(nPop, pops, fits, ranks, distances)   
    
            iter += 1 
        print("\n") 
        # 获取等级为0,即实际求解得到的帕累托前沿 
        paretoPops = pops[ranks==0] 
        paretoFits = fits[ranks==0] 
        
        return paretoPops, paretoFits
    

    由父代种群和经过差分变异交叉后的实验种群混合成一个新的种群,对新的种群进行非支配排序,利用1对1锦标赛选择算子筛选出新的父代种群。

    2. NSGA2-非支配排序遗传算法

    采用精英策略,在进行交叉变异操作之后对新产生的种群与父代种群混合成新的种群,对新的种群进行优选。

    算法主程序

    def NSGA2(nIter, nChr, nPop, pc, pm, etaC, etaM, func, lb, rb): 
        """非支配遗传算法主程序 
        Params:
            nIter: 迭代次数 
            nPop: 种群大小 
            pc: 交叉概率 
            pm: 变异概率 
            func: 优化的函数 
            lb: 自变量下界
            rb: 自变量上界
         Return:
            paretoPops: 帕累托解集 
            paretoFits: 对应的适应度  
        """   
        # 生成初始种群 
        pops = initPops(nPop, nChr, lb, rb)  
        fits = fitness(pops, func) 
    
        # 开始第1次迭代 
        iter = 1 
        while iter <= nIter:
            print(f"当前正在第{iter}代....")
            ranks = nonDominationSort(pops, fits)  # 非支配排序 
            distances = crowdingDistanceSort(pops, fits, ranks)  # 拥挤度
            pops, fits = select1(nPop, pops, fits, ranks, distances) 
            chrpops = crossover(pops, pc, etaC, lb, rb)  # 交叉产生子种群 
            chrpops = mutate(chrpops, pm, etaM, lb, rb)  # 变异产生子种群 
            chrfits = fitness(chrpops, func)  
            # 从原始种群和子种群中筛选 
            pops, fits = optSelect(pops, fits, chrpops, chrfits)  
            iter += 1 
        # 对最后一代进行非支配排序 
        ranks = nonDominationSort(pops, fits)  # 非支配排序 
        distances = crowdingDistanceSort(pops, fits, ranks)  # 拥挤度 
        paretoPops = pops[ranks==0] 
        paretoFits = fits[ranks==0] 
        return paretoPops, paretoFits 
    

    3. MOPSO-多目标粒子群算法

    从archive集中更新gBest不仅采用支配解,还利用网格法,统计支配解的密度,选取网格中密度较低的解来更新gBest。

    算法主程序

    def MOPSO(nIter, nPop, nAr, nChr, func, c1, c2, lb, rb, Vmax, Vmin, M):
        """多目标粒子群算法
        Params:
            nIter: 迭代次数 
            nPOp: 粒子群规模 
            nAr: archive集合的最大规模 
            nChr: 粒子大小 
            func: 优化的函数
            c1、c2: 速度更新参数 
            lb: 解下界
            rb:解上界 
            Vmax: 速度最大值 
            Vmin:速度最小值 
            M: 划分的栅格的个数为M*M个
        Return:
            paretoPops: 帕累托解集
            paretoPops:对应的适应度 
        """
        # 种群初始化 
        pops, VPops = initPops(nPop, nChr, lb, rb, Vmax, Vmin) 
        # 获取个体极值和种群极值 
        fits = fitness(pops, func) 
        pBest = pops 
        pFits = fits 
        gBest = pops
        # 初始化archive集, 选取pops的帕累托面即可
        archive, arFits = getNonDominationPops(pops, fits) 
        wStart = 0.9 
        wEnd = 0.4  
    
        # 开始主循环 
        iter = 1 
        while iter <= nIter:
            print("【进度】【{0:20s}】【正在进行{1}代...】【共{2}代】".\
                format('▋'*int(iter/nIter*20), iter, nIter), end='\r') 
    
            # 速度更新 
            w = wStart - (wStart-wEnd) * (iter/nIter)**2 
            VPops = w*VPops + c1*np.random.rand()*(pBest-pops) + \
                c2*np.random.rand()*(gBest-pops) 
            VPops[VPops>Vmax] = Vmax 
            VPops[VPops<Vmin] = Vmin 
            # 坐标更新 
            pops += VPops 
            pops[pops<lb] = lb 
            pops[pops>rb] = rb  # 防止过界 
            fits = fitness(pops, func) 
    
            # 更新个体极值 
            pBest, pFits = updatePBest(pBest, pFits, pops, fits) 
            # 更新archive集 
            archive, arFits = updateArchive(pops, fits, archive, arFits) 
            # 检查是否超出规模,如果是,那么剔除掉一些个体 
            archive, arFits = checkArchive(archive, arFits, nAr, M)  
            # 重新获取全局最优解
            gBest = getGBest(pops, fits, archive, arFits, M)  
            iter += 1 
        print('\n')
        paretoPops, paretoFits = getNonDominationPops(archive, arFits) 
        return paretoPops, paretoFits 
    

    4. 测试算例

    FON标准问题:
    f1(x1,x2,x3)=1ei=13(xi13),f2(x1,x2,x3)=1ei=13(xi+13)f_1(x_1,x_2,x_3)=1-e^{-\sum_{i=1}^3(x_i-\frac{1}{\sqrt{3}})}, f_2(x_1,x_2,x_3)=1-e^{-\sum_{i=1}^{3}(x_i+\frac{1}{\sqrt{3}})}
    其中:xi[2,2],i=1,2,3x_i\in[-2,2],i=1,2,3

    该问题具有极为简单易于表达的理论最优解集
    x1=x2=x3[13,13]x_1=x_2=x_3\in[-\frac{1}{\sqrt3},\frac{1}{\sqrt3}]

    4. 测试结果

    4.1. 多目标差分进化算法求解结果

    (迭代次数100,种群规模50)
    img

    4.2. NSGA2算法求解结果

    (迭代次数50,种群规模100)
    img

    4.3 MOPSO算法求解结果

    (迭代次数100,种群规模100)
    img

    4.4 结果对比

    • 求解速度:MOPSO > MODA > NSGA2
    • 求解质量:MOPSO > NSGA2 > MODA

    5. 参考文献

    参考文献:多目标差分进化在热连轧负荷分配中的应用
    参考博客:多目标优化算法(一)NSGA-Ⅱ(NSGA2)
    参考文献:MOPSO算法及其在水库优化调度中的应用
    详细代码地址部分多目标启发式算法python实现(github)

    展开全文
  • 程序为用户提供了从以下选项中选择启发式选项的选项:a。)放置错位的瓷砖的数量,曼哈顿距离作为启发式b。)解决难题的曼哈顿距离。 然后列出需要解决的步骤数量,要解决的步骤,以及最终在解决方案之前探索了...
  • 是一个集成的计算与资源环境,其目标是要把分布在不同地方的各种资源,女ncPu、存储器、程序、数据等联合起来,形成一个虚 拟的、统一的、强大的计算环境,把这些分散的资源统一成一个能协同工作的网络计算机。网格...
  • 用模拟退火算法对自来水管网进行标定 意大利面食 网络:重复使用实用程序 libs-epanet :继续前进 src :模拟的基本权利。 graficos-fobjetivo :继续前进,继续前进,继续前进,继续前进
  • 构造启发式算法:最邻近插入法

    千次阅读 2014-11-09 20:58:48
    一、背景 二、原理 三、程序原理
  • 九宫图的启发式搜索算法程序和广度搜索算法程序及报告
  • 该存储库包含用于自动拟合混合图(带有 ),使用启发式算法来迭代拟合日益复杂的模型的Python代码,以及用于计算贝叶斯因子(带有 )以比较拟合模型的R代码。 该启发式搜索算法首先”一文中进行了描述。 该代码...
  • 遗传算法(Genetic Algorithm)是一种模拟自然界“自然选择”和“自然遗传”的启发式搜索算法,通过模拟自然进化过程搜索最优解的方法。直到1989年,实现了具有单变量函数的简单遗传算法(Simple Genetic Algorithm...
  • 启发式搜索算法求解八数码问题(C)

    万次阅读 多人点赞 2012-08-07 21:19:16
    下午看一个游戏的算法时看了一下启发式搜索算法,心血来潮跑了一遍很久很久以前写八数码的程序(C语言),发现各种问题,后来顺着思路整理了一下,贴出来和大家分享一下,直接上代码: // // main.c // yunsuan ...
  • 启发式搜索程序设计-八数码问题

    千次阅读 2009-08-09 13:28:00
    (1)、启发函数设定   由八数码问题的部分状态图可以看出,从初始节点开始,在通向目标节点的路径上,各节点的数码格局同目标节点相比较,其数码不同的位置...(2)、数据结构与算法设计   数码结构体 typedef str
  • 针对通信范围值未知的情况,提出了一种结合改进的差分进化算法和启发式算法的算法。 所开发的算法具有新的交叉程序,并且经过改进的程序可以生成新一代的个人/候选人。 还为搜索过程设计了“单节点处理”过程,以...
  • 1程序源代码 #include <stdio.h> #include<malloc.h> struct node{ int a[3][3];// 用二维数组存放 8 数码 int hx;// 函数 h x 的值表示与目标状态的差距 struct node *parent;// 指向父结点的指针 struct node *...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 368
精华内容 147
热门标签
关键字:

启发式算法程序