精华内容
下载资源
问答
  • 2-opt优化——C语言实现

    千次阅读 2019-08-01 13:52:45
    概述 一般情况下,我们找最优路径采取贪心(greedy)策略,都可以收到一个比较好的成效,但是如果我们想要得到一个更优的解,这时候就...这里就介绍一种2-opt的优化方式。 基本思想 其实2-opt的想法非常简单 (1)我...

    概述

    一般情况下,我们找最优路径采取贪心(greedy)策略,都可以收到一个比较好的成效,但是如果我们想要得到一个更优的解,这时候就需要对我们的贪心策略进行优化。但是其实用一个算法找到最优的解是一个非常困难的问题,我们一般会用一个概率上的优化,就是如果重复次数足够多,找不到一个更好的解,我们就认为这个解是最优的。这里就介绍一种2-opt的优化方式。

    基本思想

    其实2-opt的想法非常简单
    (1)我们随机交换路径中的两个点的位置(当然也要保留这两个点之间的路径)
    比如说原路径为1 2 3 4 5,交换2, 5,我们得到的新路径为1 5 4 3 2
    (2)如果交换后的路径比原来的路径更加优化(一般是对比路径和),我们就保留交换后的路径。
    (3)重复(1),(2)直到交换N次仍然无法更新路径停止。

    具体实现的时候,首先是得到一条路径,我们可以随机给出一条路径,或者是用贪心先找到一条路径(推荐后者,因为这样更新路径的次数会少一些),然后生成两个随机数表示交换的两点,关于循环的次数N的选取,要自己经过试验选取一个较为合适的数字(较小则无法找到更优的解,较大导致运算时间过长,要自己实验得出最优化的选择)

    操作步骤

    (1)使用贪心算法找到一条路径记录在数组A中,并记录下总路径长l1。
    (2)随机生成两个不同的随机数n1,n2(将其对应到路径中顶点的下标),交换路径中n1,n2之间的路径,得到一条新路径并记录下路径总长l2。
    (3)比较新得到的路径总长与原来的路径总长,若新路径更短,则更新路径为新路径并将计数器cnt_opt置0。否则计数器加1.
    (4)重复(2),(3),直到计数器cnt_opt达到MaxCount,MaxCount即为上面提到的合理选择的循环次数N。

    代码实现

    int main() {
    	game_state_t state;
    	memset(&state, 0, sizeof(state));
    	init(&state);
    	// write your code here
    	int i, j;
    	int cnt_opt = 0;
    	double minpath = 0;
    	double minpath1 = 0;
    	n = state.n;
    	m = state.m;
    	op.x = state.start_x, op.y = state.start_y;
    	AdjGraph G;
    	Init(state, &G);
    	Floyd(G);
    	int num_in = (state.start_x * m + state.start_y);
    	for (i = 0; i < n; i++) {
    		for (j = 0; j < m; j++) {
    			if (state.food[i][j] == 1) {
    				n_food[count] = i * m + j;
    				count++;
    			}
    		}
    	}
    	count1 = count;          
    	while (count > 0) {      //这个while循环是用贪心找到一条路径
    		int nearest;
    		double MIN = 9999.9;
    		for (i = 0; i < m * n; i++) {
    			int u = i / m;
    			int v = i % m;
    			if (state.food[u][v] == 1 && A[num_in][i] < MIN && num_in != i) {
    				MIN = A[num_in][i];
    				nearest = i;
    			}
    		}
    		minpath += MIN;
    		int num_out = nearest;
    		num_in = num_out;
    		state.food[num_out / m][num_out % m] = 0;
    		pathway[count1 - count] = num_out;
    		count--;
    	}
    	num_in = (state.start_x * m + state.start_y);
    	srand((unsigned)time(NULL));          //随机数种子
    	while (cnt_opt <= MaxCount) {          //2-opt算法的循环
    		int n1, n2;
    		n1 = rand() % count1;
    		do {
    			n2 = rand() % count1;    
    
    		} while (n1 == n2);
    		if (n1 > n2) {
    			swap(&n1, &n2);
    		}
    		int left = n1, right = n2;
    		while (left < right) {           //交换两个随机数之间的路径得到新路径
    			swap(&pathway[left], &pathway[right]);
    			left++; right--;
    		}
    		minpath1 = 0;
    		for (i = 0; i < count1 - 1; i++) {
    			minpath1 += A[pathway[i]][pathway[i + 1]];
    		}
    		minpath1 += A[num_in][pathway[0]];
    		if (minpath1 < minpath) {
    			minpath = minpath1;
    			cnt_opt = 0;
    		}
    		else {
    			left = n1, right = n2;
    			while (left < right) {
    				swap(&pathway[left], &pathway[right]);
    				left++; right--;
    			}
    			cnt_opt++;
    		}
    	}
    	for (i = 0; i < count1; i++) {
    		int num_out = pathway[i];
    		BFS(G, num_in, num_out);
    		transfor(num_out, &state);
    		j = 0;
    		while (path_BFS[j] != num_out) {
    			printf("%c", p[j]);
    			j++;
    		}
    		num_in = num_out;
    	}
    	destroy(&state);
    	system("PAUSE");
    	return 0;
    }
    

    这个代码实现的问题是一个简单的吃豆人寻找最优吃豆路径的算法,地图数据存储在util.h头文件里面,还有较多的数据结构为给出有需要的自取源码
    https://github.com/yiguang-hack/2-opt/tree/master

    展开全文
  • 2-OPT作用:随机是其中的两个点换位置(注意保留原有链接),例如:2和5换位置,要保证3还是和2挨着,序列会变成1 5 4 3 2 6 7 优化:序列变动之后,与原序列,对比路径和,如果路径和变短则更新路径 循环:重复上述...

    算法通俗解释

    优化对象:一个路径序列例如:1 2 3 4 5 6 7
    2-OPT作用:随机是其中的两个点换位置(注意保留原有链接),例如:2和5换位置,要保证3还是和2挨着,序列会变成1 5 4 3 2 6 7
    优化:序列变动之后,与原序列,对比路径和,如果路径和变短则更新路径
    循环:重复上述步骤,设置循环次数,次数达到就跳出循环。

    完整代码

    import numpy as np
    import matplotlib.pyplot as plt
    from mysql import *
    
    MAXCOUNT = 10
    
    def calDist(xid, yid, durationlist):
        for dura in durationlist:
            if dura['origin'] == xid and dura['destination'] == yid:
                return dura['duration']
    
    
    def calPathDist(LocidList, durationlist):
        sum = 0
        for i in range(1, len(LocidList)):
            sum += calDist(LocidList[i], LocidList[i - 1], durationlist)
        return sum
    
    
    # path1长度比path2短则返回true
    def pathCompare(path1, path2, LocidList, durationlist):
        LocidList1 = []; LocidList2 = []
        for i in path1:
            LocidList1.append(LocidList[i])
        for i in path2:
            LocidList2.append(LocidList[i])
        if calPathDist(LocidList1, durationlist) <= calPathDist(LocidList2, durationlist):
            return True
        return False
    
    
    def generateRandomPath(bestPath):
        a = np.random.randint(len(bestPath))
        while True:
            b = np.random.randint(len(bestPath))
            if np.abs(a - b) > 1:
                break
        if a > b:
            return b, a, bestPath[b:a + 1]
        else:
            return a, b, bestPath[a:b + 1]
    
    
    def reversePath(path):
        rePath = path.copy()
        rePath = reversed(rePath)
        return list(rePath)
    
    
    def updateBestPath(bestPath, LocidList, durationlist):
        count = 0
        while count < MAXCOUNT:
            start, end, path = generateRandomPath(bestPath)
            rePath = reversePath(path)
            # print('path:', path,'repath:', rePath, 'end:', end)
            if pathCompare(path, rePath, LocidList, durationlist):
                count += 1
                continue
            else:
                count = 0
                print('path:', path, 'repath:', rePath, 'end:', end)
                bestPath[start:end+1] = rePath
        return bestPath
    
    
    def ProduceInput(routes):
        routes_pathindex = np.arange(0, len(routes))
        test = mysql()
        orderlist = test.findALLorder()
        duration = test.findALLduration()
        location = test.findAllloc()
        orderlist_route = []
        for order in orderlist:
            if str(order['OrderId']) in routes:
                orderlist_route.append(order)
        LocId = []
        for order in orderlist_route:
            LocId.append(test.findloc(order['Lat'], order['Lng']))
    
        return routes_pathindex, LocId, duration
    
    
    if __name__ == '__main__':
        routes = ['40001', '40003', '40002', '40004', '40005', '40006', '40007', '40008']
        #注明:routes_pathindex是路径的下标,LocId保存的是所有点的位置,duration保存的是各个位置之间的距离单位
        (routes_pathindex, LocId, duration) = ProduceInput(routes)
        print(updateBestPath(routes_pathindex, LocId, duration))
    
    
    展开全文
  • 2-opt其实是2-optimization的缩写,简言之就是两元素优化。也可以称作2-exchange 。

    2-opt其实是2-optimization的缩写,简言之就是两元素优化。也可以称作2-exchange 。(摘自百度百科)

    这个一种随机性算法,基本思想就是随机取两个元素进行优化,一直到无法优化为止。在小规模TSP问题上,2-opt无论从效率还是效果上都优于蚁群算法。

    最初这个算法就是在解决TSP问题上取得了比较好的成效,这里也以TSP问题为例。

    TSP(旅行商)问题:假设有十一座城市,一位旅行商要经过这十一座城市并且最终返回出发的城市,求解最短的路线。

    使用2-opt思想解决该问题的算法如下(首先设置参数最大迭代次数maxCount,初始化计数器count为0):

    1. 随机选择一条路线(比方说是A->B->C->D->E->F->G),假设是最短路线min;
    2. 随机选择在路线s中不相连两个节点,将两个节点之间的路径翻转过来获得新路径,比方我们随机选中了B节点和E节点,则新路径为A->(E->D->C->B)->F->G,()部分为被翻转的路径;
    3. 如果新路径比min路径短,则设新路径为最短路径min,将计数器count置为0,返回步骤2,否则将计数器count加1,当count大于等于maxCount时,算法结束,此时min即为最短路径,否则返回步骤2;

    在网上没能找到相关的python代码实现,于是我就自己粗糙地实现了一个(数据来源于某次华为杯数学建模竞赛):

    # -*- coding: utf-8 -*-
    """
    Created on Fri Jul 21 13:47:57 2017
    
    @author: 燃烧杯
    """
    
    import numpy as np
    import matplotlib.pyplot as plt
    
    #在这里设置迭代停止条件,要多尝试一些不同数值,最好设置大一点
    MAXCOUNT = 100
    
    #数据在这里输入,依次键入每个城市的坐标
    cities = np.array([
            [256, 121], 
            [264, 715], 
            [225, 605],
            [168, 538],
            [210, 455],
            [120, 400],
            [96, 304],
            [10,451],
            [162, 660],
            [110, 561],
            [105, 473]
            ])
    
    def calDist(xindex, yindex):
        return (np.sum(np.power(cities[xindex] - cities[yindex], 2))) ** 0.5
    
    def calPathDist(indexList):
        sum = 0.0
        for i in range(1, len(indexList)):
            sum += calDist(indexList[i], indexList[i - 1])
        return sum    
    
    #path1长度比path2短则返回true
    def pathCompare(path1, path2):
        if calPathDist(path1) <= calPathDist(path2):
            return True
        return False
        
    def generateRandomPath(bestPath):
        a = np.random.randint(len(bestPath))
        while True:
            b = np.random.randint(len(bestPath))
            if np.abs(a - b) > 1:
                break
        if a > b:
            return b, a, bestPath[b:a+1]
        else:
            return a, b, bestPath[a:b+1]
        
    def reversePath(path):
        rePath = path.copy()
        rePath[1:-1] = rePath[-2:0:-1]
        return rePath
        
    def updateBestPath(bestPath):
        count = 0
        while count < MAXCOUNT:
            print(calPathDist(bestPath))
            print(bestPath.tolist())
            start, end, path = generateRandomPath(bestPath)
            rePath = reversePath(path)
            if pathCompare(path, rePath):
                count += 1
                continue
            else:
                count = 0
                bestPath[start:end+1] = rePath
        return bestPath
        
        
    def draw(bestPath):
        ax = plt.subplot(111, aspect='equal')
        ax.plot(cities[:, 0], cities[:, 1], 'x', color='blue')
        for i,city in enumerate(cities):
            ax.text(city[0], city[1], str(i))
        ax.plot(cities[bestPath, 0], cities[bestPath, 1], color='red')
        plt.show()
        
    def opt2():
        #随便选择一条可行路径
        bestPath = np.arange(0, len(cities))
        bestPath = np.append(bestPath, 0)
        bestPath = updateBestPath(bestPath)
        draw(bestPath)
        
    opt2()
    
    

    运行结果(只取了最后两行输出):

    1511.49908777
    [0, 4, 3, 2, 1, 8, 9, 10, 7, 5, 6, 0]
    

    运行结果

    注:因为该算法具有随机性,所以每次运行的结果可能都有所不同,但是大多都是在1500~1600之内,要多运行几次比较一下取较好的结果,我上面给的运行结果就是我在几次运行中挑选得比较好的一次

    关于调参:
    本算法只有COUNTMAX一个参数,用于设置算法的停止条件,当算法已经连续COUNTMAX次没能得到更好的路径时便会停止,经过试验,一般设置大一些效果会比较好,但是大到一定程度的情况下再增大数值算法的效果也不会变得更好。

    展开全文
  • 最基本的蚁群算法+2opt邻域搜索_求解TSP(.xls格式)
  • Python 实现K-OPT算法(及通俗解释)

    千次阅读 2019-07-07 21:56:47
    K-OPT的特点,就是把路径随机分成K段然后,然后调用2-OPT,由于有很多段,但不是每一段都要使用2-OPT,所以这产生了很多种组合方式:1段使用、2段使用…K段使用,所以,每一种都要尝试,若出现更优的路径,就留下来...

    算法解释

    首先第一步要看懂的2-OPT的算法,不懂得参考链接:https://blog.csdn.net/qq_30008595/article/details/95033476
    K-OPT的特点,就是把路径随机分成K段然后,然后调用2-OPT,由于有很多段,但不是每一段都要使用2-OPT,所以这产生了很多种组合方式:1段使用、2段使用…K段使用,所以,每一种都要尝试,若出现更优的路径,就留下来,不然就不留下来。
    推荐一个paper(可能要翻墙):https://pdfs.semanticscholar.org/ab7c/c83bb513a91b06f6c8bc3b9da7f60cbbaee5.pdf

    完整代码

    import random
    import numpy as np
    import matplotlib.pyplot as plt
    import TWOPT
    from itertools import combinations, permutations
    
    
    MAXCOUNT = 1
    
    def KDevide(routes_length, k):
        PartNumber = []
        for i in range(len(routes_length)):
            if len(PartNumber) == 0:
                PartNumber.append(random.randint(0, len(routes_length) - 1))
            else:
                if PartNumber[i-1]+2 < len(routes_length) - 1:
                    PartNumber.append(random.randint(PartNumber[i-1]+2, len(routes_length) - 1))
                else:
                    break
        return PartNumber
    
    def Update_routes(routes, PartNumber):
        Part_Routes = []
        # routes.remove(7)
        for Part_i in range(len(PartNumber)):
            if Part_i == 0:
                Part_Route = routes[0:PartNumber[Part_i]]
                Part_Routes.append(Part_Route)
                continue
            elif  Part_i <= len(PartNumber) - 1:
                print(Part_i, PartNumber[Part_i])
                Part_Route = routes[PartNumber[Part_i-1]:PartNumber[Part_i]]
            else:
                break
            if len(Part_Route) != 0:
                Part_Routes.append(Part_Route)
        print(PartNumber[-1])
        if PartNumber[-1] != 7:
            Part_Routes.append(routes[PartNumber[-1]:])
        else:
            Part_Routes.append([7])
    
        return Part_Routes
    
    def UpdatePartPath(bestPath, LocidList, durationlist):
        count = 0
        while count < MAXCOUNT:
            start, end, path = TWOPT.generateRandomPath(bestPath)
            rePath = TWOPT.reversePath(path)
            print('path:', path,'repath:', rePath, 'end:', end)
            if TWOPT.pathCompare(path, rePath, LocidList, durationlist):
                count += 1
                continue
            else:
                count = 0
                print('path:', path, 'repath:', rePath, 'end:', end)
                bestPath[start:end+1] = rePath
        return bestPath
    
    def Combination(Part_Routes):
        Part = []
        for i in range(len(Part_Routes)):
            Part.append(i)
        Modify_parts = []
        for i in range(len(Part_Routes)):
            Modify_parts.append(list(combinations(Part,i+1)))
        return Modify_parts
    
    
    #列举排列结果 Modify_parts: [[(1, 2)], [(1, 2), (2, 3)]] Modify_part: [(1, 2), (2, 3)]
    def UpdateOnece(Modify_parts, Part_Routes):
        temp = Part_Routes
        UpdateRoutes = []
        for Modify_part in Modify_parts:
            for Modify_subpart in Modify_part:
                Part_Routes = temp.copy()
                for Modify_subsubpart in Modify_subpart:
                    Part_Routes[Modify_subsubpart] = TWOPT.reversePath(Part_Routes[Modify_subsubpart])
                UpdateRoutes.append(Part_Routes)
        return UpdateRoutes
    
    def Merge(UpdateRoutes):
        Merge_Routes = []
        for UpdateRoute in UpdateRoutes:
            Merge_Route = []
            for SubUpdateRoute in UpdateRoute:
                Merge_Route.extend(SubUpdateRoute)
            Merge_Routes.append(Merge_Route)
        return Merge_Routes
    
    routes = ['40001', '40003', '40002', '40004', '40005', '40006', '40007', '40008']
    (routes_pathindex, LocId, duration) = TWOPT.ProduceInput(routes)
    k = KDevide(routes_pathindex, 4)
    test = Update_routes(routes_pathindex, k)
    result = UpdateOnece(Combination(test), test)
    print(Merge(result))
    
    展开全文
  • mysqldmp 参数之--skip-opt 与--opt

    千次阅读 2017-01-06 11:01:56
    1、首先我们通过mysqldump 的help 帮助我们了解一下两个参数... --opt  Same as --add-drop-table, --add-locks, --create-options, --quick, --extended-insert, --lock-tables, --set-charset, and --disable-k
  • scikit-opt实现遗传算法

    千次阅读 2020-07-16 18:01:54
    最近学了下遗传算法,然后用scikit-opt包实现了一下,玩了一玩,这个包继承了scikit learn的编写思路,使用起来很简单,而且是中国人写的,文档里有中文版和英文版。官方链接,不过似乎这个包写的时间还不长,使用的...
  • Python Scikit-opt调包实践

    千次阅读 2020-07-31 21:44:59
    今天看见原来Python也有相应的优化算法包scikit-opt,但安装时出现了问题,具体可见博客。 接下来就开始快乐的学习调包吧! 今天主要学习遗传算法和模拟退火算法实现,先对这两种算法做一个简单介绍。 遗传算法 遗传...
  • FAQ系列 | mysqldump选项之skip-opt

    千次阅读 2017-11-22 17:06:00
    最近在用mysqldump备份时,想要把数据表和数据分开备份,因此做了2次备份。 执行备份数据库表结构时,指定了 --skip-opt 选项,相当于禁用下面几个参数: --add-drop-table,--add-locks, --create-options,--quick,-...
  • mysqldump的--skip-opt问题

    千次阅读 2011-12-27 09:52:15
    遇到过好几次mysqldump出来的备份不能导入,同样的库如果mysqldump --skip-opt是可以导入的,分析两个不同的备份文件,发现--skip-opt是一条条的insert语句,但是--opt一个表只有1条insert语句,这样有可能表数据太...
  • 分析Android sensor ...由于我使用的是Android 5.1(kernel 3.10) ,不自带 opt3001的驱动,我发现kernel 4.10 已经自带opt3001的驱动。我不会为了一个驱动而换掉 kernel。而且 kernel 4.10 opt3001的驱动高度...
  • 1.从github下载zip,tar.gz等压缩包解压后,进入解压目录。...2.安装完后,打开jupyter notebook输入:from bayes_opt import BayesianOptimization 检测是否安装成功,不报错就安装成功。 注:bayes...
  • 局部搜索算法

    千次阅读 2019-03-24 09:10:22
    文章目录@[toc]路径内搜索2-optOr-opt路径间搜索Swap/shift2-opt*参考文献 局部搜索算法是在一组可行解的基础上,在当前解的领域内进行局部搜索产生新的可行解的过程。 主要有路径内搜索和路径间搜索,以下都以VRP为...
  • 在有关Email营销和邮件列表的英文文章中,经常会出现一些专业词汇或者缩写字母,常见的有:PEM,UCE, Opt-in,Double Opt-In,Opt-out等,其中部分术语可能没有非常贴切的中文词汇。根据作者个人的理解,在《Email...
  • Docker Security

    千次阅读 2018-05-09 17:36:16
    1、linux内核的namespace和cgroup。...2、docker daemon的攻击。 3、容器的配置文件漏洞,默认的或者用户自定义的配置文件。 4、内核的“强化”安全功能,以及它们如何与容器交互。linux内核的namespaceDocker
  • Python实现粒子群算法PSO

    千次阅读 2017-12-06 19:10:27
    去github上吧scikit-opt这个库下载下来, https://github.com/guofei9987/scikit-opt 如果不想下载整个库,也可以只下载pso.py这个文件PSOdef demo_func2(p): # Sphere函数 out_put = 0 for i in p: out_put +...
  • nginx1.14.2错误:./configure: error

    千次阅读 2018-12-29 00:16:50
    错误1:./configure: error: the invalid value in --with-ld-opt="-Wl,-z,relro -specs=/usr/lib/rpm/redhat/redhat-hardened-ld -Wl,-E" 解决方法:yum -y install redhat-rpm-config.noarch 错误2:....
  • /local/etc/chilli.conf"' -DDEFPIDFILE='"/usr/local/var/run/chilli.pid"' -DDEFSTATEDIR='"/usr/local/var/run"' -DSBINDIR='"/usr/local/sbin"' -g -O2 -MT main-opt.o -MD -MP -MF .deps/main-opt.Tpo -c -o ...
  • JAVA_OPT理解及调优理论

    千次阅读 2019-03-25 16:30:00
    以RocketMQ的namesrv和broker启动为例,理解CMS和G1垃圾收集器下的jdk参数 CMS垃圾收集器 ...set "JAVA_OPT=%JAVA_OPT% -server -Xms2g -Xmx2g -Xmn1g -XX:MetaspaceSize=128m -XX:MaxMetaspac...
  • docker更换文件系统(Overlay2

    千次阅读 2018-01-08 21:57:06
    Either use `--storage-opt dm.thinpooldev` or use `--storage-opt dm.no_warn_on_loop_devices=true` to suppress this warning. 这就是文件系统没有用比较优秀的 # systemctl stop docker # rm -rf /var/lib/...
  • [Opt 31-67] Problem

    千次阅读 2017-11-20 11:15:32
    [Opt 31-67] Problem: A LUT2cell in the design is missing a connection on input pin I0, which is used by the LUT equation.  原因:上游IP或模块的输出没有驱动导致。 (或者:输出信号定义错误,...
  • 在运行gazebo的过程中,出现了...[gazebo-2] process has died [pid 28003, exit code 255, cmd /opt/ros/indigo/lib/gazebo_ros/gzserver worlds/empty.world __name:=gazebo __log:=/home/exbot/.ros/log/3bd6002c...
  • 使用VIVADO编译代码时,其中一个IP报错,错误类似为ImplementationOpt Design[Opt 31-67] Problem: A LUT2 cell in the design is missing a connection on input pin I0, which is used by the LUT equation....
  • 使用Python实现遗传算法

    千次阅读 2017-12-06 15:07:22
    我们使用scikit-opt工具箱来实现遗传算法:https://github.com/guofei9987/scikit-opt 下载后,我们只需要其中的ga.py文件首先,定义一个目标函数def demo_func2(p): x, y, z = p return -(x ** 2 + y ** 2 + z **...
  • 【FPGA_020】[Opt 31-67] Problem

    千次阅读 2018-06-27 20:24:24
    [Opt 31-67] Problem: A LUT2cell in the design is missing a connection on input pin I0, which is used by the LUT equation.      原因:上游IP或模块的输出没有驱动导致。 (或者:输出信号定义错...
  • java opt 设置

    千次阅读 2015-12-25 10:18:08
    -Xms2048m -Xmx2048m -XX:PermSize=512m -XX:MaxPermSize=512m -Xss256k -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled -XX:+UseFastAccessorMethods -XX:ParallelCMSThreads=20 -XX:+CMSClassUn
  • 这个问题就是importError: /opt/ros/kinetic/lib/python2.7/dist-packages/cv2.so,为什么会出现这个问题?因为当初安装cv2的时候,默认弄在了Python2,所以导致这个错误的产生,解决办法在这篇文章中被找到。不过...
  • docker 设置日志文件大小及个数

    万次阅读 2019-05-20 23:14:56
    docker容器在运行一定时间后会产生大量的日志,导致磁盘空间问题出现。 现在有2个方案可以限制...docker run --log-opt max-size=10m --log-opt max-file=3 全局范围内 修改docker daemon.json文件,配置日志文件...
  • OPT和LRU算法C语言实现

    热门讨论 2012-11-19 18:10:01
    用C语言实现的OPT和LRU算法,下载后直接用VC++6.0打开即可编译运行。亲测可用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 510,155
精华内容 204,062
关键字:

2-opt