runs算法

⑴ 电脑里的重要文件在属性—高级里做了加密，重装系统后拒绝访问了，拜问高人如何才能恢复啊

前段时间，在网络HI里接到一位网友的求助，内容大致类似如下：电脑在重装系统后无法打开某文件夹了，提示没有权限。D盘是NTFS格式，该朋友在重装系统前对该文件夹加了密！又没有导出密钥来备份。总说NTFS格式的安全性比FAT32高，其中一点就体现在这个EFS加密上，基本上无法破解。
先简单介绍一下如何加密吧：右击需要加密的文件或文件夹，选[属性]——[高级]——[加密...]即可。加密后的文件夹为绿色，只有实施加密的用户才能打开，有人会说那重装系统后创建一个同名同密码的用户就行了吧，NO！涉及到很多问题：

EFS加密是通过对称算法加密的，2000支持DES，XP支持DES和3DES。但是加密所用的密钥是经过公钥算法加密的，这种算法几乎无法破解（暴力破解可以，但是不现实），而且加密的关键在于用户的SID，这个东西每次创建用户随机生成，就算用户名一致，也不行的。你的数据已经经过加密了，保存在硬盘上的就不是原来的数据了，所以不可能这么简单就访问到。2000毕竟还是C1级别的操作系统呢，如果企业的重要数据经过EFS加密，如果容易解密，后果不可想象。另外文件权限也是记录在NTFS分区的ACL（访问控制表）里的，所以只要是微软出的操作系统，都会严格检查的，ERD2003是基于Windows PE的，所以也会检查的。Windows XP也可以设置文件权限，只要选择我的文档，属性中设置为私有，就可以保证自己的了。但是更详细的设置，必须解除简单文件共享(不推荐，不安全)。
如果仅仅是权限，你重装系统后，可以用Administrators组的管理员帐号强行获取文件的控制权（先解除简单文件共享，然后在文件的属性-权限里添加你的新管理员帐号，赋予完全控制），但是加密的就无济于事了。

因此：

如果事先保存有密钥的话，那么任何用户只要安装这个密钥就可以打开加密的文件夹了。如何创建密钥呢？运行CERTMGR.MSC会打开证书管理器，找到[个人]证书下的[XXX]证书（XXX就是你的用户名），右击它选择[所有任务]——[导出]导出并保存EFS证书。当你需要时可双击导出的密钥文件，按提示安装即可。

——————————SID安全标识符介绍—————通俗地理解为操作系统的“身份证”—————

SID也就是安全标识符（Security Identifiers），是标识用户、组和计算机帐户的唯一的号码。在第一次创建该帐户时，将给网络上的每一个帐户发布一个唯一的 SID。Windows 2000 中的内部进程将引用帐户的 SID 而不是帐户的用户或组名。如果创建帐户，再删除帐户，然后使用相同的用户名创建另一个帐户，则新帐户将不具有授权给前一个帐户的权力或权限，原因是该帐户具有不同的 SID 号。安全标识符也被称为安全 ID 或 SID。

SID的作用

用户通过验证后，登陆进程会给用户一个访问令牌，该令牌相当于用户访问系统资源的票证，当用户试图访问系统资源时，将访问令牌提供给 Windows NT，然后 Windows NT 检查用户试图访问对象上的访问控制列表。如果用户被允许访问该对象，Windows NT将会分配给用户适当的访问权限。

访问令牌是用户在通过验证的时候有登陆进程所提供的，所以改变用户的权限需要注销后重新登陆，重新获取访问令牌。

SID号码的组成

如果存在两个同样SID的用户，这两个帐户将被鉴别为同一个帐户，原理上如果帐户无限制增加的时候，会产生同样的SID，在通常的情况下SID是唯一的，他由计算机名、当前时间、当前用户态线程的CPU耗费时间的总和三个参数决定以保证它的唯一性。

一个完整的SID包括：

• 用户和组的安全描述

• 48-bit的ID authority

• 修订版本

• 可变的验证值Variable sub-authority values

例：S-1-5-21-310440588-250036847-580389505-500

我们来先分析这个重要的SID。第一项S表示该字符串是SID；第二项是SID的版本号，对于2000来说，这个就是1；然后是标志符的颁发机构（identifier authority），对于2000内的帐户，颁发机构就是NT，值是5。然后表示一系列的子颁发机构，前面几项是标志域的，最后一个标志着域内的帐户和组。

SID的获得

开始－运行－regedt32－HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Builtin\Aliases\Members，找到本地的域的代码，展开后，得到的就是本地帐号的所有SID列表。

其中很多值都是固定的，比如第一个000001F4（16进制），换算成十进制是500，说明是系统建立的内置管理员帐号administrator，000001F5换算成10进制是501，也就是GUEST帐号了，详细的参照后面的列表。

这一项默认是system可以完全控制，这也就是为什么要获得这个需要一个System的Cmd的Shell的原因了，当然如果权限足够的话你可以把你要添加的帐号添加进去。

或者使用Support Tools的Reg工具：

reg query "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList

还有一种方法可以获得SID和用户名称的对应关系：

1. Regedt32:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion \ProfileList

2. 这个时候可以在左侧的窗口看到SID的值，可以在右侧的窗口中ProfileImagePath看到不同的SID关联的用户名，

比如%SystemDrive%\Documents and Settings\Administrator.momo这个对应的就是本地机器的管理员SID

%SystemDrive%\Documents and Settings\Administrator.domain这个就是对应域的管理员的帐户

另外微软的ResourceKit里面也提供了工具getsid，sysinternals的工具包里面也有Psgetsid，其实感觉原理都是读取注册表的值罢了，就是省了一些事情。

SID重复问题的产生

安装NT／2000系统的时候，产生了一个唯一的SID，但是当你使用类似Ghost的软件克隆机器的时候，就会产生不同的机器使用一个SID的问题。产生了很严重的安全问题。

同样，如果是重复的SID对于对等网来说也会产生很多安全方面的问题。在对等网中帐号的基础是SID加上一个相关的标识符（RID），如果所有的工作站都拥有一样的SID，每个工作站上产生的第一个帐号都是一样的，这样就对用户本身的文件夹和文件的安全产生了隐患。

这个时候某个人在自己的NTFS分区建立了共享，并且设置了自己可以访问，但是实际上另外一台机器的SID号码和这个一样的用户此时也是可以访问这个共享的。

SID重复问题的解决

下面的几个试验带有高危险性，慎用，我已经付出了惨痛的代价！

微软在ResourceKit里面提供了一个工具，叫做SYSPREP,这个可以用在克隆一台工作站以前产生一个新的SID号码。 下图是他的参数

这个工具在DC上是不能运行这个命令的，否则会提示

但是这个工具并不是把所有的帐户完全的产生新的SID，而是针对两个主要的帐户Administrator和Guest，其他的帐号仍然使用原有的SID。

下面做一个试验，先获得目前帐号的SID： S-1-5-21-2000478354-688789844-839522115

然后运行Sysprep，出现提示窗口：

确定以后需要重启，然后安装程序需要重新设置计算机名称、管理员口令等，但是登陆的时候还是需要输入原帐号的口令。

进入2000以后，再次查询SID，得到：

S-1-5-21-759461550-145307086-515799519，发现SID号已经得到了改变，查询注册表，发现注册表已经全部修改了，当然全部修改了。

另外sysinternals公司也提供了类似的工具NTSID，这个到后来才发现是针对NT4的产品，界面如下：

他可不会提示什么再DC上不能用，接受了就开始，结果导致我的一台DC崩溃，重启后提示“安全账号管理器初始化失败，提供给识别代号颁发机构的值为无效值，错误状态0XC0000084，请按确定，重启到目录服务还原模式...”，即使切换到目录服务还原模式也再也进不去了！

想想自己胆子也够大的啊，好在是一台额外DC，但是自己用的机器，导致重装系统半天，重装软件N天，所以再次提醒大家，做以上试验的时候一定要慎重，最好在一台无关紧要的机器上试验，否则出现问题我不负责哦。另外在Ghost的新版企业版本中的控制台已经加入了修改SID的功能，自己还没有尝试，有兴趣的朋友可以自己试验一下，不过从原理上应该都是一样的。

文章发表之前，又发现了微软自己提供的一个工具“Riprep”，这个工具主要用做在远程安装的过程中，想要同时安装上应用程序。管理员安装了一个标准的公司桌面操作系统，并配置好应用软件和一些桌面设置之后，可以使用Riprep从这个标准的公司桌面系统制作一个Image文件。这个Image文件既包括了客户化的应用软件，又把每个桌面系统必须独占的安全ID、计算机账号等删除了。管理员可以它放到远程安装服务器上，供客户端远程启动进行安装时选用。但是要注意的是这个工具只能在单硬盘、单分区而且是Professional的机器上面用。

⑵ 如何用Linux做一个功能完备的路由器

路由协议的介绍 我们这里介绍一下RIP协议。 RIP是Routing Information Protocol的缩写，直接翻译就是"路由信息协议"。 RIP计算路由时使用了"距离向量（distance vector）"算法，因此，它也被称作"距离向量寻路协议（distance vector routing protocol）。 RIP的特点是路由器间定时地交换网络的整体知识，并且只和相邻路由器交换这种知识。换句话说，路由器只和相邻路由器共享网络信息。路由器一旦从相邻路由器获取了新的知识，就将其追加到自己的数据库中，并将该信息传递给所有的相邻的路由器。相邻路由器做同样的操作，经过若干次传递，使自治系统内的所有路由器都能获得完整的路由信息。 RIP报文用UDP数据报来传送。为了区别于其他的UDP应用，规定RIPng的公认专用UDP端口号为521。主动寻路更新报文的源/目的的端口都是RIPng端口，应答的更新报文送往发起请求的端口。应当注意，IPv4中RIP使用的端口号是520，与RIPng的有所不同。 定时器爱RIP中有着比较重要的作用。在RIP中为支持寻路操作使用了三个不同的定时器。 第一个是启动定时进行RIP更新操作的定时器。此定时器通常设置成30秒。在RIP标准中对其进一步加以限制，它要求路由器对更新报文的发送间隔采用随机数，将RIP更新报文的间隔选取在25秒到35秒之间。其目的是为了避免网络上所有的路由器以相同的定时发送更新报文，大量的业务量压迫网络造成冲突。利用随机间隔可均衡业务量，从而减少路由器的冲突。 RIP在避免冲突方面还有一点需要注意，在触发更新中不论何时发送了报文，不对30秒定时器复位。如果复位，多个路由器的更新报文的发送间隔就会发生冲突。这是由于所有的路由器在发送触发更新后同时启动定时器造成的。如不对该定时器复位，即使与在数秒前刚广播的触发更新报文的内容完全一样，定时的更新报文也照发不误。 RIP使用的第二个定时器时期满（expiration）定时器。路由器只要收到通往特定信宿的路由，就对通往该信宿的期满定时器初始化。期满定时器虽然被设定为180秒，但在稳定的网络中总是每隔30秒被初始化。当网络不稳定时，此定时器的时间区间表示该路由无效。 RIP最后一个定时器时垃圾收集（garbage collection）定时器。路由器对无效路由打上尺度为无穷大的无效标记并将垃圾收集定时器置位。此时，定时器在120秒的区间内工作。在该期间内路由器将尺度费用置成无穷大的同时，继续公布该信宿。以这种方法公布路由，相邻路由表就能迅速从寻路表中删除该路由。 RIP协议也有它的缺陷： 网络直径较小 RIP将尺度（即费用）无穷大定义为16，这一定义对使用RIP的所有网络的规模作出了严格的限制。因尺度必须是整数，故网络的费用至少为1。在基于RIP的Internet中，所有的系统距其他任何系统不能超过15个网络。这一大小被称作网络直径。 这一限制对管理员分配费用的灵活性是一个很大的制约。管理员分配费用最直接的方法是对各个网络的费用都设成1。但是，在这种分配方式下，RIP就会选择费用最小的路径，而不管该路径上的信道容量的大小。因此会舍弃"较长"的高速路径而通过低效的"较短"路径传送数据。为了避免这种情况的发生，管理员可将大于1的费用分配给低效链路，人为地提高其费用。其结果是最大网络直径随之变小，进一步限制了RIP的网络规模。 对网络变化的反应较慢 RIP网络中的路由器从路由失效到将其识别出来要等待180秒，而在OSPF中典型值是1~2秒。 不支持组播 在RIP中没有公布组成员信息的方法，因此不支持组播寻路。为实现组播寻路需和其他协议并用。 gated的配置 gated支持RIP、OSPF、IS-IS等路由协议。我们这里着重介绍RIP协议的配置方法，其他协议的配置大家可以针对协议本身然后参考相关帮助文档做类似的配置就可以。 首先修改/etc/sysconfig/network文件，使得FORWARD_IPV4=yes。然后在/etc/目录下创建文件名为gated.conf的文件，里面就是需要填写的配置信息。RIP协议的配置语法如下： rip yes │ no │ on │ off [ { broadcast ; nobroadcast ; nocheckzero ; preference preference; defaultmetric metric ; query authentication [none │ [[simple│md5] password]] ; interface interface_list [noripin] │ [ripin] [noripout] │ [ripout] [metricin metric] [metricout metric] [version 1]│[version 2 [multicast│broadcast]] [[secondary] authentication [none │ [[simple│md5] password]] ; trustedgateways gateway_list ; sourcegateways gateway_list ; traceoptions trace_options ; } ] ; 上面的配置语法用来启动或者禁止RIP协议的运行，并对RIP协议某些参数进行设置。各参数的含义如下： broadcast 指明RIP分组将被广播。当广播静态路由或者由其他协议产生的RIP路由项时，这很有用。 nobroadcast 指明当然的接口上不广播RIP分组。 nocheckzero 指明RIP不处理RIP分组中的保留域。通常RIP将拒绝保留域为非零的分组。 preference preference 设置RIP路由的preference，其缺省值是100，这个值可以被其他的给定的策略重写。 metric metric 定义当使用RIP广告由其他路由协议获得的路由信息时使用的尺度（metric）。其缺省值为16（不可达）。 query authentication [none │ [[simple│md5] password]] ; 设定身份认证密码。缺省是无需认证。 interface interface_list 针对某特定的接口进行参数设定。 可以有的参数如下： noripin 指定该接口商接收的RIP分组无效。 ripin 这是缺省的参数。与noripin相反。 noripout 被指定的接口上将无RIP分组发出。缺省值是在所有的广播和非广播的接口商发送送RIP分组。 ripout 这是缺省值。与noripout的含义相反。 metricin metric 指定在新添加的路由表项加入内核路由表以前增加的尺度（metric）。缺省值是1。 metricout metric 指定通过特定的接口发出的RIP前，对尺度的增加值。缺省值是0。 version 1 指定发送第一个版本的RIP协议的分组。缺省值是这个。 version 2 在指定的接口商发送第二个版本的RIP协议分组。如果IP组播可以使用，则缺省发送完全第二版本的分组，如果不支持组播，则使用与第一版本兼容的第二版本的RIP分组。 multicast 指明在特定接口上的第二版本的RIP分组使用组播发送。 broadcast 指明在特定的接口上使用广播来发送与第一版本兼容的第二版本的RIP分组，即使该接口支持组播。 [secondary] authentication [none │ [simple│md5] password] 定义身份认证的方式。只对第二版本的RIP协议有用。缺省是无身份认证。 trustedgateways gateway_list 定义RIP接收RIP更新分组的网关。gateway_list 是一个简单的主机名或者IP地址的列表。缺省情况下，在共享网络上的所有的路由器都被认为支持提供RIP更新信息。 sourcegateways gateway_list 定义RIP直接发送分组的路由器列表，而不通过组播或者广播。 traceoptions trace_options 设置RIP跟踪选项。详细设置略。 下面是些配置示例： 配置1： # # # This configuration runs RIP in quiet mode, it only listens to # packets, no matter how many interfaces are configured. # rip yes { nobroadcast ; } ; 配置2： # This configuration emulates routed. It runs RIP and only sends # updates if there are more than one interfaces up and IP forwarding is # enabled in the kernel. # # NOTE that RIP *will not* run if UDP checksums are disabled in # the kernel. # rip yes ; zebra介绍 这是日本人写的以GNU版权方式发布的软件，开始于1996年，主要的功能是实现了RIPv1,RIPv2,RIPng, OSPFv2, OSPFv3, BGP-4, and BGP-4+路由协议，目前是0.87版，目前支持Linux和FreeBSD，将来会支持Solaris 7和GNU Hurd。 其中RIPv1, RIPv2, OSPFv2是用于IPv4的自治域系统内部网络路由协议，最好的是OSPF，他支持VLSM(变长子网掩码）、收敛快，能根据链路的负载等动态调整路由，是目前最好的所有厂商都支持的内部路由协议。跟他差不多（也许还要好）的是cisco专有的EIGRP. BGP-4是用于自治域系统之间的外部网络路由协议，也是目前Internet主干上目前使用的协议，非常的灵活。在国外用的非常普遍，如果一个网络有两个以上出口(连接两个ISP)极大的可能会用他。但是在国内好象很少使用，这也跟国内的网络比较封闭有关。假如我们跟CSTNET和CETNET使用BGP-4的话，只要这两个出口一个是通的，我们对外的连接不会中断超过1分钟。 RIPng OSPFv3, BGP-4+主要扩展了对ipv6的支持。 这个软件配置的很多方面跟cisco的IOS配置几乎完全相同，我们完全可以拿一台PC机来完成一些必须用昂贵的CISCO路由器才能完成的比较复杂的路由协议处理控制功能。 GNU Zebra可以到www.zebra.org去找。 路由器上的策略控制:IP带宽管理(QoS) 为什么要管理带宽? 因特网的成功主要因素是IP（Internet Protocol）协议族的简单和稳健。现在几乎所有的人都在向IP靠拢，甚至传统的电讯公司也在将它们的基于电路交换的语音网络向IP网络转。然而基于IP协议的因特网这时候就遇到了一个非常大的困难。它不相ATM协议，它是平等地对待任何业务，也就是说所有的通过IP网络的数据都被平等地尽可能好的传送（称：尽力型服务）。如果我愿意多付1倍的钱，我也不能让我的主页下载的速度提高一倍。这时候就引入了QoS概念，也就是服务质量保证。这种情况下，平等对待所有IP业务数据的方法就要被放弃，而试图区分不同的用户或业务，然后分配不同的带宽。这就是路由器上的带宽的分配和管理。

⑶ 暗黑中装备的价值怎么算呀

物品的稀有度的顺序
从最低到最高：低品质的物品；正常物品；超强的物品；魔法物品；套装物品和稀有物品(亮金物品)(机率相同)；暗金物品。
低品质的物品与超强的物品的掉落机率的比例与怪物等级(杀死怪物时掉落)或场景等级(开箱子的时候)有关。
物品与金币掉落在地上以后会消失。如果不是特殊需要，不要把物品放在地上时间太长。一般的物品和金币会在15分钟之后消失，魔法物品、稀有物品、套装物品及暗金物品将在大约一小时后消失。

耐久度
残酷的战斗会对英雄的装备造成损害，最终使之无法使用。这在游戏中表现为物品耐久度数值的下降——当鼠标指上去时。前面的数字表示该物品现有的耐久度，后面的表示物品的总耐久度。 当物品的耐久度很低时，屏幕右上方会显示物品的轮廓。低耐久度的物品会显示为黄色。当物品显示为红色时表示它的耐久度为0，无法使用，需要马上修理。营地里的铁匠会修理你的物品，修理魔法物品会花费很多钱，不过一般来讲这笔钱是值得的。
城镇里的特定NPC可以受雇修理你的武器和装甲。为防止在战斗中物品损坏的危险情况，建议每次回城都修理你的物品。
物品可以被部分地修复，条件是物品没有完全损坏（耐久度为0），你身上又有金币。修复物品时身上的金币如果不够，物品的耐久度不会加满。0耐久度的物品必须被完全修复。
物品耐久度上限为255。

无形的物品
装甲或武器，包括有魔法属性的，有时会以“无形的”形式出现。这些物品会呈半透明状。无殂的物品会具有更高的耐久度，但不能被修复。你可以在上面镶嵌 Zod 的符文以防止它损坏。佣兵使用无形的物品并不会减少耐久度。魔法、稀有及暗金物品也可以是无形的，但无形的物品能被注入（ACT1的第五个任务的奖励）。
用坏的无形物品只能卖 1块钱。

什么是“劣质的”、“粗糙的”、“破碎的”、“损坏的”物品？
这些物品的最大耐久度将比普通的低，但弓仍不会损坏的。武器会有较低的伤害，装甲的防御也会比同种装甲更低些。

“超强的”装甲与武器
超强的装甲额外地增加防御或是耐久度；超强的武器会增加你的命中率或伤害，或是耐久度。

头环
头环与头盔会有其他物品上没有的前后缀。戴上头环以后屏幕上并不会显示，你可以看到人物原有的发式，比如亚马逊的金发。但头环比通常的头盔的防御值要低。

角色专用装备
有些装备是为特定角色准备的，属性专为这种角色设计。在属性的描述中，最上面有解释，这物品是否是角色专属。

聚气物品
新的魔法物品会准许任何角色使用其他角色的技能。一些物品会在特定情况下触发特定的技能，比如攻击敌人或被敌人攻击。聚气物品允许装备者任意使用这项技能，但次数有限。可以通过鼠标点击技能选择或按S键可以选择这项技能，聚气技能会和普通技能一起显示，点击该图标选择项技能，然后右键点击目标即可使用。聚气技能的使用次数有限，所以你需要注意图标上面显示的次数限制。聚气耗尽后，你可以回到附近的城市中，修理物品会加满物品的聚气。

武器速度与种类（等级）
特定的武器在特定的角色手中会发挥更好的作用。属性中列出的速度(“慢速”、“急速”等)与该特定角色有关。武器速率的描述，像它的实际挥舞的速度一样，对不同的角色会有不同。而这个描述也只是相对的，标着“快速”攻击速度的匕首会比一个“快速”的钉头锤慢些，但两者都比“普通”攻击速度的木棍要快。
武器的基础速度可以用数字来表示，数字越大速度越慢。比如[0], [-20], [20]的三件武器，[20]是这里最慢的基础攻击速率。

如果我有一把“急速”的剑，然后装备上增加攻击速率的装备，是否会更快？
是的。对大部分人来讲，没有最快只有更快。

有什么办法知道你是否达到了最快的武器速度么？
不，没有简单的办法判断是否达到了极限。比“急速”的攻击速度更快也是可能的。(你可以试试野蛮人的“狂怒”Frenzy技能，看看可以达到多快)。很难达到最高的速度，但达到最高速度后任何武器几乎是一样的，不管是长柄武器还是单手剑。

物品上的额外的伤害是怎么样计算的？
例如，你有一件物品有国王的（King's）、屠杀之（Slaughter）的词缀，前者提供200%的增强伤害，后者增加20点最大伤害，那么计算时先计算200%增强伤害，然后再加20点最大伤害。
在这种情况下，我们先计算百分比的加成，再计算大小伤害值的加成。再计入神殿、光环等其他效果的时候算式会更加复杂。

武器伤害值
“对不死系的伤害”和“对恶魔的伤害”不会在屏幕上出现，它们将被独立计算。

怪物会掉落特定的物品么？
不，不过金色怪物和头目会有更好的机率掉落魔法物品，头目会掉落魔法物品或更多的黄金。不过，怪物的种类与掉落的物品没有关系。

人物的等级与掉落的物品有关么？
不，掉落的物品只与怪物等级与场景等级有关。

锁住的箱子会掉更好的东西么？
不，但它会掉出更多的东西，一般来说是没上锁的两倍。

人物之间转移物品 (国度或是开放战网的人物)
你可以找一个朋友呆在游戏里，以保持转移物品时这个游戏里有人。
对于BN上同一国度的人物，你可以建议一个带密码的游戏。如果你在一个游戏里呆超过5分钟，所有人离开这个游戏之后它会继续存在一段时间。如果你的手足够快，你可以把物品扔在城里，退出换个人物再进这个游戏捡起来。但这样是不安全的，如果你无法及时重进游戏，你扔下的物品会消失。
单机的人物无法互相转移物品。

暴雪对人物之间转移物品的政策是什么？
暴雪不支持Diablo II的人物之间交换物品。在网上，试图交换物品是不安全的，如果丢失物品，暴雪并不为此负责。在Diablo II中，背包里和储物箱里的空间是有限的，因为设计者希望玩家自己决定哪些物品应该保留，哪些应该丢掉或卖掉。

怎样找到更好的装备？
下面有些关于找到“更好”，也就是说更多的稀有、套装或暗金装备的窍门，你可以把你找到的用不着的物品用来交易：

· 带上更多的MF(XX%更佳机会获得魔法物品)物品。
· 打开所有的箱子、石头、木桶…… 箱子和其他类似的东西会落出东西，结合更高的MF百分比你翻箱子时会掉出更好的东西。有些地方的箱子比其他地方更多些。如果你不是刺客，最好带上钥匙以打那些锁住的箱子。你可以把钥匙放在赫拉迪克方块里。

· 重复杀死蓝色或金色的怪物 如果可能的话，把它们杀光！它们有相当高的掉落机率，你可以试着找到有更多、更容易干掉的蓝色及金色怪物的地方。

· 重复杀每一场景的头目. 每一幕的头目，如Diablo和Baal有相当高的掉落机率，你可以一遍遍杀它们，以得到更好的东西。你不会每次都得到好东西，但机率的确会增加。提高MF值会提升这个机率。"Baal Runs"是十分流行的。

· 重复杀死超级金怪及完成任务时杀死的怪物 Bishibosh(冰冷之原的那个黄金的萨满巫师)、Rakanishu (石块旷野那个电强的黄金小怪)，血鸟、女侯爵这样的小BOSS的掉落率比其他的要高。另外，女侯爵可能掉落更高级的符文。

· 杀死更多的怪物 一般来讲，单位时间内杀死的怪物越多，得到好东西的机率越大。杀死怪物和掉落物品的机率共同决定了你得到东西的好坏。所以剥皮丛林这样的地方会十分盛行。你一定会希望可以找一个你可以一次杀死很多怪物的地方。

· 激活每个怪物神殿 Monster Shrines 和邪气之罐 Evil Urns. 这样会创造出一个金色或蓝色怪物，会给你带来更好的战利品。

⑷ 问一个算法问题

suppose we are comparing implementations of insertion sort and merge sort on the same machine .for inputs of size n,insertion sort runs in 8n^2 steps,while merge sort runs in 64n lgn steps. for which values of n does insertion sort beat merge sort?

⑸ 应用遗传算法求解tsp问题程序有那个高手帮帮我啊谢谢啦

#include <cmath>

#include <ctime>

#include <vector>

#include <map>

#include <string>

#include <iostream>

#include <algorithm>

using namespace std;

float pcross = 0.85; //交叉率

float pmutation = 0.1; //变异率

int popsize = 300; //种群大小

const int lchrom = 20; //染色体长度

int gen; //当前世代

int maxgen = 100; //最大世代数

int run; //当前运行次数

int maxruns =10; //总运行次数

float max_var = 9 ; //路径最大连接开销!!

//基因定义(一个城市)

struct Gene

{

string name;

map<Gene*,float> linkCost; //该城市到其它城市的路程开销

};

//染色体定义(到各城市顺序的一种组合)

struct Chrom

{

vector<Gene*> chrom_gene; //染色体（到各城市去的顺序）

float varible; //路程总开销

float fitness; //个体适应度

};

//种群定义

struct Pop

{

vector<Chrom> pop_chrom; //种群里的染色体组

float sumfitness; //种群中个体适应度累计

};

Pop oldpop; //当前代种群

Pop newpop; //新一代种群

vector<Gene> genes(lchrom); //保存全部基因

//产生一个随机整数(在low和high之间)

inline int randomInt(int low,int high)

{

if(low==high)

return low;

return low+rand()%(high-low+1);

}

//计算一条染色体的个体适应度

inline void chromCost(Chrom& chr)

{

float sum=0;

for(int i=0;i<chr.chrom_gene.size()-1;i++)

{

sum += (chr.chrom_gene[i])->linkCost[chr.chrom_gene[i+1]];

}

sum += (chr.chrom_gene.front())->linkCost[chr.chrom_gene.back()];

chr.varible=sum;

chr.fitness=max_var*(lchrom) - chr.varible;

}

//计算一个种群的个体适应度之和

inline void popCost(Pop &pop)

{

float sum=0;

for(int i=0;i<pop.pop_chrom.size();i++)

{

sum+=pop.pop_chrom[i].fitness;

}

pop.sumfitness = sum;

}

void outChrom(Chrom& chr);

//随机初始化一条染色体

inline void initChrom(Chrom& chr)

{

vector<int> tmp(lchrom);

for(int i=0;i<lchrom;i++)

tmp[i]=i;

int choose;

while(tmp.size()>1)

{

choose=randomInt(0,tmp.size()-1);

chr.chrom_gene.push_back(&genes[tmp[choose]]);

tmp.erase(tmp.begin()+choose);

}

chr.chrom_gene.push_back(&genes[tmp[0]]);

chromCost(chr);

}

//随机初始化种群

inline void initpop(Pop& pop)

{

pop.pop_chrom.reserve(popsize);

Chrom tmp;

tmp.chrom_gene.reserve(lchrom);

for(int i=0;i<popsize;i++)

{

initChrom(tmp);

pop.pop_chrom.push_back(tmp);

tmp.chrom_gene.clear();

}

popCost(pop);

}

//轮盘赌选择,返回种群中被选择的个体编号

inline int selectChrom(const Pop& pop)

{

float sum = 0;

float pick = float(randomInt(0,1000))/1000;

int i = 0;

if(pop.sumfitness!=0)

{

while(1)

{

sum += pop.pop_chrom[i].fitness/pop.sumfitness;

i++;

if( (sum > pick) || i==pop.pop_chrom.size()-1)

return i-1; }

}

else

return randomInt(0,pop.pop_chrom.size()-2);

}

//精英策略，返回最优秀的一条染色体

inline int chooseBest(const Pop& pop)

{ int choose = 0;

float best = 0;

for(int i = 0;i< pop.pop_chrom.size();i++)

{ if(pop.pop_chrom[i].fitness > best)

{ best = pop.pop_chrom[i].fitness;

choose = i;}

}

return choose；}

//染色体交叉操作,由两个父代产生两个子代(顺序交叉OX)

inline void crossover(Chrom& parent1,Chrom& parent2,Chrom& child1,Chrom& child2)

{ child1.chrom_gene.resize(lchrom);

child2.chrom_gene.resize(lchrom);

vector<Gene*>::iterator v_iter,p1_beg,p2_beg,c1_beg,c2_beg,p1_end,p2_end,c1_end,c2_end;

p1_beg = parent1.chrom_gene.begin();

p2_beg = parent2.chrom_gene.begin();

c1_beg = child1.chrom_gene.begin();

c2_beg = child2.chrom_gene.begin();

p1_end = parent1.chrom_gene.end();

p2_end = parent2.chrom_gene.end();

c1_end = child1.chrom_gene.end();

c2_end = child2.chrom_gene.end();

vector<Gene*> v1(parent2.chrom_gene), v2(parent1.chrom_gene); //用于交叉的临时表

//随机选择两个交叉点

int pick1 = randomInt(1,lchrom-3);

int pick2 = randomInt(pick1+1,lchrom-2);

int dist = lchrom-1-pick2; //第二交叉点到尾部的距离

//子代保持两交叉点间的基因不变

(p1_beg+pick1, p1_beg+pick2+1, c1_beg+pick1);

(p2_beg+pick1, p2_beg+pick2+1, c2_beg+pick1);

//循环移动表中元素

rotate(v1.begin(), v1.begin()+pick2+1,v1.end());

rotate(v2.begin(), v2.begin()+pick2+1,v2.end());

//从表中除去父代已有的元素

for(v_iter = p1_beg+pick1; v_iter!=p1_beg+pick2+1; ++v_iter)

remove(v1.begin(),v1.end(),*v_iter);

for(v_iter = p2_beg+pick1; v_iter!=p2_beg+pick2+1; ++v_iter)

remove(v2.begin(),v2.end(),*v_iter);

//把表中元素复制到子代中

(v1.begin(), v1.begin()+dist, c1_beg+pick2+1);

(v1.begin()+dist, v1.begin()+dist+pick1, c1_beg);

(v2.begin(), v2.begin()+dist, c2_beg+pick2+1);

(v2.begin()+dist, v2.begin()+dist+pick1, c2_beg);

}

//染色体变异操作,随机交换两个基因

inline void mutation(Chrom& chr)

{

vector<Gene*>::iterator beg = chr.chrom_gene.begin();

int pick1,pick2;

pick1 = randomInt(0,lchrom-1);

do{

pick2 =randomInt(0,lchrom-1);

}while(pick1==pick2);

iter_swap(beg+pick1, beg+pick2);

}

//世代进化(由当前种群产生新种群)

void generation(Pop& oldpop,Pop& newpop)

{ newpop.pop_chrom.resize(popsize);

int mate1,mate2,j;

float pick;

float tmp;

Chrom gene1,gene2,tmp1,tmp2;

gene1.chrom_gene.resize(lchrom);

gene2.chrom_gene.resize(lchrom);

tmp1.chrom_gene.resize(lchrom);

tmp2.chrom_gene.resize(lchrom);

//将最佳染色体放入下一代

mate1 = chooseBest(oldpop);

newpop.pop_chrom[0] = oldpop.pop_chrom[mate1];

j = 1;

//产生两条新染色体

do{

int count = 0;

mate1 = selectChrom(oldpop);

mate2 = selectChrom(oldpop);

pick = float(randomInt(0,1000))/1000;

gene1= oldpop.pop_chrom[mate1];

gene2= oldpop.pop_chrom[mate1];

if(pick < pcross) //交叉操作

{

int count = 0;

bool flag1 = false;

bool flag2 = false;

while(1)

{

crossover(oldpop.pop_chrom[mate1],oldpop.pop_chrom[mate2],tmp1,tmp2);

chromCost(tmp1); //计算适应度

chromCost(tmp2);

if(tmp1.fitness > gene1.fitness)

{

gene1 = tmp1;

flag1 = true;}

if(tmp2.fitness > gene2.fitness)

{

gene2 = tmp2;

flag2 = true;

}

if((flag1==true && flag2==true) || count> 50)

{

newpop.pop_chrom[j] = gene1;

newpop.pop_chrom[j+1] = gene2;

break;

}

count++;

}

}

else

{

newpop.pop_chrom[j].chrom_gene = oldpop.pop_chrom[mate1].chrom_gene;

newpop.pop_chrom[j+1].chrom_gene = oldpop.pop_chrom[mate2].chrom_gene;

chromCost(newpop.pop_chrom[j]);

chromCost(newpop.pop_chrom[j+1]);

}

pick = float(randomInt(0,1000))/1000;

if(pick < pmutation) //变异操作

{

int count = 0;

do{

tmp = newpop.pop_chrom[j].fitness;

mutation(newpop.pop_chrom[j]);

chromCost(newpop.pop_chrom[j]); //计算适应度

count++;

}while(tmp > newpop.pop_chrom[j].fitness && count < 50);

}

pick = float(randomInt(0,1000))/1000;

if(pick < pmutation) //变异操作

{

int count = 0;

do{

tmp = newpop.pop_chrom[j+1].fitness;

mutation(newpop.pop_chrom[j+1]);

chromCost(newpop.pop_chrom[j+1]); //计算适应度

count++;

}while(tmp > newpop.pop_chrom[j+1].fitness && count < 50);

}

//chromCost(newpop.pop_chrom[j]); //计算适应度

//chromCost(newpop.pop_chrom[j+1]);

j += 2;

}while(j < popsize-1);

popCost(newpop); //计算新种群的适应度之和

}

//输出一条染色体信息

inline void outChrom(Chrom& chr)

{

cout<<endl<<"路径:";

for(int i=0;i<lchrom;i++)

{

cout<<chr.chrom_gene[i]->name;

}

cout<<endl<<"回路总开销:"<<chr.varible<<endl;

cout<<"适应度:"<<chr.fitness<<endl;

}

int main()

{

cout<<"*************用遗传算法解决TSP(旅行商)问题******************"<<endl;

string names[lchrom]={"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T"};//基因（城市）名称

//用矩阵保存各城市间的路程开销

float dist[lchrom][lchrom] ={{0, 1, 4, 6, 8, 1, 3, 7, 2, 9, 7, 3, 4, 5, 8, 9, 2, 8, 2, 8},{1, 0, 7, 5, 3, 8, 3, 4, 2, 4, 4, 6, 2, 8, 2, 9, 4, 5, 2, 1},{4, 7, 0, 3, 8, 3, 7, 9, 1, 2, 5, 8, 1, 8, 9, 4, 7, 4, 8, 4},{6, 5, 3, 0, 3, 1, 5, 2, 9, 1, 3, 5, 7, 3, 4, 7, 3, 4, 5, 2},

{8, 3, 8, 3, 0, 2, 3, 1, 4, 6, 3, 8, 4, 5, 2, 8, 1, 7, 4, 7},{1, 8, 3, 1, 2, 0, 3, 3, 9, 5, 4, 5, 2, 7, 3, 6, 2, 3, 7, 1},{3, 3, 7, 5, 3, 3, 0, 7, 5, 9, 3, 4, 5, 9, 3, 7, 3, 2, 8, 1},{7, 4, 9, 2, 1, 3, 7, 0, 1, 3, 4, 5, 2, 7, 6, 3, 3, 8, 3, 5},

{2, 2, 1, 9, 4, 9, 5, 1, 0, 1, 3, 4, 7, 3, 7, 5, 9, 2, 1, 7},{9, 4, 2, 1, 6, 5, 9, 3, 1, 0, 3, 7, 3, 7, 4, 9, 3, 5, 2, 5},{7, 4, 5, 3, 3, 4, 3, 4, 3, 3, 0, 5, 7, 8, 4, 3, 1, 5, 9, 3},{3, 6, 8, 5, 8, 5, 4, 5, 4, 7, 5, 0, 8, 3, 1, 5, 8, 5, 8, 3},

{4, 2, 1, 7, 4, 2, 5, 2, 7, 3, 7, 8, 0, 5, 7, 4, 8, 3, 5, 3},{5, 8, 8, 3, 5, 7, 9, 7, 3, 7, 8, 3, 5, 0, 8, 3, 1, 8, 4, 5},{8, 2, 9, 4, 2, 3, 3, 6, 7, 4, 4, 1, 7, 8, 0, 4, 2, 1, 8, 4},{9, 9, 4, 7, 8, 6, 7, 3, 5, 9, 3, 5, 4, 3, 4, 0, 4, 1, 8, 4},

{2, 4, 7, 3, 1, 2, 3, 3, 9, 3, 1, 8, 8, 1, 2, 4, 0, 4, 3, 7},{8, 5, 4, 4, 7, 3, 2, 8, 2, 5, 5, 5, 3, 8, 1, 1, 4, 0, 2, 6},{2, 2, 8, 5, 4, 7, 8, 3, 1, 2, 9, 8, 5, 4, 8, 8, 3, 2, 0, 4},{8, 1, 4, 2, 7, 1, 1, 5, 7, 5, 3, 3, 3, 5, 4, 4, 7, 6, 4, 0}};

//初始化基因(所有基因都保存在genes中)

int i,j;

for(i=0;i<lchrom;i++)

{

genes[i].name =names[i];

for(j=0;j<lchrom;j++)

{

genes[i].linkCost[&genes[j]] = dist[i][j];

}

}

//输出配置信息

cout<<"\n染色体长度:"<<lchrom<<"\n种群大小:"<<popsize<<"\n交叉率:"<<pcross<<"\n变异率:"<<pmutation;

cout<<"\n最大世代数:"<<maxgen<<"\n总运行次数:"<<maxruns<<"\n路径最大连接开销:"<<max_var<<endl;

//输出路径信息

cout<<endl<<" ";

for(i=0;i<lchrom;i++)

cout<<genes[i].name<<" ";

cout<<endl;

for(i=0;i<lchrom;i++)

{

cout<<genes[i].name<<":";

for(j=0;j<lchrom;j++)

{

cout<<genes[i].linkCost[&genes[j]]<<" ";

}

cout<<endl;

}

cout<<endl;

int best;

Chrom bestChrom; //全部种群中最佳染色体

bestChrom.fitness = 0;

float sumVarible = 0;

float sumFitness = 0;

//运行maxrns次

for(run = 1;run<=maxruns;run++)

{

initpop(oldpop); //产生初始种群

//通过不断进化，直到达到最大世代数

for(gen = 1;gen<=maxgen;gen++)

{

generation(oldpop,newpop); //从当前种群产生新种群

oldpop.pop_chrom.swap(newpop.pop_chrom);

oldpop.sumfitness = newpop.sumfitness;

newpop.pop_chrom.clear();

}

best = chooseBest(oldpop); //本次运行得出的最佳染色体

if(oldpop.pop_chrom[best].fitness > bestChrom.fitness)

bestChrom = oldpop.pop_chrom[best];

sumVarible += oldpop.pop_chrom[best].varible;

sumFitness += oldpop.pop_chrom[best].fitness;

cout<<run<<"次"<<"Best:";

outChrom(oldpop.pop_chrom[best]); //输出本次运行得出的最佳染色体

cout<<endl;

oldpop.pop_chrom.clear();

}

cout<<endl<<"一条最佳染色体:";

outChrom(bestChrom); //输出全部种群中最佳染色体

cout<<endl<<endl<<"最佳染色体平均开销:"<<sumVarible/maxruns;

cout<<endl<<"最佳染色体平均适应度:"<<sumFitness/maxruns<<endl;

system("PAUSE");

return 0;

}

上次做大作业的时候做的，可以运行的。有什么问题再问。

⑹ 如何在Vivado中使用Tcl脚本替代约束

Vivado是Xilinx最新的FPGA设计工具，支持7系列以后的FPGA及Zynq 7000的开发。与之前的ISE设计套件相比，Vivado可以说是全新设计的。无论从界面、设置、算法，还是从对使用者思路的要求，都是全新的。看了大家很多的博文，基本上都是用GUI创建工程，那我就简单介绍一下Vivado的脚本使用。

在ISE设计套件中，支持多种脚本： 可以用xperl来运行perl脚本，可以用xtclsh来运行Tcl脚本，还可以用windows批处理脚本来运行设计流程。

ISE集成的Tcl脚本解释器为8.4版本。同时，ISE GUI中的Tcl console功能不够强大，部分组件使用的脚本也与Tcl有不同，导致Tcl脚本在ISE上并不十分流行。

在Vivado上，Tcl已经成为唯一支持的脚本。并且，所有操作都有对应的Tcl脚本可以执行。所以，掌握Tcl脚本语言对掌握Vivado的使用有重要帮助。

Vivado上集成的Tcl脚本解释器为8.5版本，也是目前比较流行的Tcl版本。Vivado的核心就是一个脚本解释器，GUI界面只是将各种脚本命令封装为图形化界面而已。

下面以Windows为平台，用脚本的思路，运行一下Vivado：

首先需要设置环境变量，在path环境变量中添加Vivado的路径，路径设置到bin文件夹，例如 C:XilinxVivado2014.1in

在Windows界面下，“开始”->“运行”，输入cmd，打开windows命令行终端。这个时候 有三个选择：

1. 输入“vivado”，启动Vivado GUI界面，和点击桌面上的图标启动Vivado没什么区别；事实上，直接点击桌面图标，就是调用windows batch命令启动vivado

2. 输入“vivado -mode batch -source file.tcl”，从脚本批处理的形式启动Vivado,运行后直接执行file.tcl文件

3. 输入“vivado -mode tcl”，启动Tcl交互式命令行。

使用第三种方法。启动后显示Vivado的版本，这里使用2014.1

⑺ 人工蜂群算法里太多比喻了，能不能就算法本身的步骤来讲讲

直接给你java代码吧，看的简单易懂
import java.lang.Math;

public class beeColony {

/* Control Parameters of ABC algorithm*/
int NP=20; /* The number of colony size (employed bees+onlooker bees)*/
int FoodNumber = NP/2; /*The number of food sources equals the half of the colony size*/
int limit = 100; /*A food source which could not be improved through "limit" trials is abandoned by its employed bee*/
int maxCycle = 2500; /*The number of cycles for foraging {a stopping criteria}*/

/* Problem specific variables*/
int D = 100; /*The number of parameters of the problem to be optimized*/
double lb = -5.12; /*lower bound of the parameters. */
double ub = 5.12; /*upper bound of the parameters. lb and ub can be defined as arrays for the problems of which parameters have different bounds*/

int runtime = 30; /*Algorithm can be run many times in order to see its robustness*/

int dizi1[]=new int[10];
double Foods[][]=new double[FoodNumber][D]; /*Foods is the population of food sources. Each row of Foods matrix is a vector holding D parameters to be optimized. The number of rows of Foods matrix equals to the FoodNumber*/
double f[]=new double[FoodNumber]; /*f is a vector holding objective function values associated with food sources */
double fitness[]=new double[FoodNumber]; /*fitness is a vector holding fitness (quality) values associated with food sources*/
double trial[]=new double[FoodNumber]; /*trial is a vector holding trial numbers through which solutions can not be improved*/
double prob[]=new double[FoodNumber]; /*prob is a vector holding probabilities of food sources (solutions) to be chosen*/
double solution[]=new double[D]; /*New solution (neighbour) proced by v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) j is a randomly chosen parameter and k is a randomlu chosen solution different from i*/

double ObjValSol; /*Objective function value of new solution*/
double FitnessSol; /*Fitness value of new solution*/
int neighbour, param2change; /*param2change corrresponds to j, neighbour corresponds to k in equation v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij})*/

double GlobalMin; /*Optimum solution obtained by ABC algorithm*/
double GlobalParams[]=new double[D]; /*Parameters of the optimum solution*/
double GlobalMins[]=new double[runtime];
/*GlobalMins holds the GlobalMin of each run in multiple runs*/
double r; /*a random number in the range [0,1)*/

/*a function pointer returning double and taking a D-dimensional array as argument */
/*If your function takes additional arguments then change function pointer definition and lines calling "...=function(solution);" in the code*/

// typedef double (*FunctionCallback)(double sol[D]);

/*benchmark functions */

// double sphere(double sol[D]);
// double Rosenbrock(double sol[D]);
// double Griewank(double sol[D]);
// double Rastrigin(double sol[D]);

/*Write your own objective function name instead of sphere*/
// FunctionCallback function = &sphere;

/*Fitness function*/
double CalculateFitness(double fun)
{
double result=0;
if(fun>=0)
{
result=1/(fun+1);
}
else
{

result=1+Math.abs(fun);
}
return result;
}

/*The best food source is memorized*/
void MemorizeBestSource()
{
int i,j;

for(i=0;i<FoodNumber;i++)
{
if (f[i]<GlobalMin)
{
GlobalMin=f[i];
for(j=0;j<D;j++)
GlobalParams[j]=Foods[i][j];
}
}
}

/*Variables are initialized in the range [lb,ub]. If each parameter has different range, use arrays lb[j], ub[j] instead of lb and ub */
/* Counters of food sources are also initialized in this function*/

void init(int index)
{
int j;
for (j=0;j<D;j++)
{
r = ( (double)Math.random()*32767 / ((double)32767+(double)(1)) );
Foods[index][j]=r*(ub-lb)+lb;
solution[j]=Foods[index][j];
}
f[index]=calculateFunction(solution);
fitness[index]=CalculateFitness(f[index]);
trial[index]=0;
}

/*All food sources are initialized */
void initial()
{
int i;
for(i=0;i<FoodNumber;i++)
{
init(i);
}
GlobalMin=f[0];
for(i=0;i<D;i++)
GlobalParams[i]=Foods[0][i];

}

void SendEmployedBees()
{
int i,j;
/*Employed Bee Phase*/
for (i=0;i<FoodNumber;i++)
{
/*The parameter to be changed is determined randomly*/
r = ((double) Math.random()*32767 / ((double)(32767)+(double)(1)) );
param2change=(int)(r*D);

/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);

/*Randomly selected solution must be different from the solution i*/
// while(neighbour==i)
// {
// r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
// neighbour=(int)(r*FoodNumber);
// }
for(j=0;j<D;j++)
solution[j]=Foods[i][j];

/*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
solution[param2change]=Foods[i][param2change]+(Foods[i][param2change]-Foods[neighbour][param2change])*(r-0.5)*2;

/*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
if (solution[param2change]<lb)
solution[param2change]=lb;
if (solution[param2change]>ub)
solution[param2change]=ub;
ObjValSol=calculateFunction(solution);
FitnessSol=CalculateFitness(ObjValSol);

/*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>fitness[i])
{

/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
trial[i]=0;
for(j=0;j<D;j++)
Foods[i][j]=solution[j];
f[i]=ObjValSol;
fitness[i]=FitnessSol;
}
else
{ /*if the solution i can not be improved, increase its trial counter*/
trial[i]=trial[i]+1;
}

}

/*end of employed bee phase*/

}

/* A food source is chosen with the probability which is proportioal to its quality*/
/*Different schemes can be used to calculate the probability values*/
/*For example prob(i)=fitness(i)/sum(fitness)*/
/*or in a way used in the metot below prob(i)=a*fitness(i)/max(fitness)+b*/
/*probability values are calculated by using fitness values and normalized by dividing maximum fitness value*/
void CalculateProbabilities()
{
int i;
double maxfit;
maxfit=fitness[0];
for (i=1;i<FoodNumber;i++)
{
if (fitness[i]>maxfit)
maxfit=fitness[i];
}

for (i=0;i<FoodNumber;i++)
{
prob[i]=(0.9*(fitness[i]/maxfit))+0.1;
}

}

void SendOnlookerBees()
{

int i,j,t;
i=0;
t=0;
/*onlooker Bee Phase*/
while(t<FoodNumber)
{

r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
if(r<prob[i]) /*choose a food source depending on its probability to be chosen*/
{
t++;

/*The parameter to be changed is determined randomly*/
r = ((double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
param2change=(int)(r*D);

/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);

/*Randomly selected solution must be different from the solution i*/
while(neighbour == i)
{
//System.out.println(Math.random()*32767+" "+32767);
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);
}
for(j=0;j<D;j++)
solution[j]=Foods[i][j];

/*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
solution[param2change]=Foods[i][param2change]+(Foods[i][param2change]-Foods[neighbour][param2change])*(r-0.5)*2;

/*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
if (solution[param2change]<lb)
solution[param2change]=lb;
if (solution[param2change]>ub)
solution[param2change]=ub;
ObjValSol=calculateFunction(solution);
FitnessSol=CalculateFitness(ObjValSol);

/*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>fitness[i])
{
/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
trial[i]=0;
for(j=0;j<D;j++)
Foods[i][j]=solution[j];
f[i]=ObjValSol;
fitness[i]=FitnessSol;
}
else
{ /*if the solution i can not be improved, increase its trial counter*/
trial[i]=trial[i]+1;
}
} /*if */
i++;
if (i==FoodNumber-1)
i=0;
}/*while*/

/*end of onlooker bee phase */
}

/*determine the food sources whose trial counter exceeds the "limit" value. In Basic ABC, only one scout is allowed to occur in each cycle*/
void SendScoutBees()
{
int maxtrialindex,i;
maxtrialindex=0;
for (i=1;i<FoodNumber;i++)
{
if (trial[i]>trial[maxtrialindex])
maxtrialindex=i;
}
if(trial[maxtrialindex]>=limit)
{
init(maxtrialindex);
}
}

double calculateFunction(double sol[])
{
return Rastrigin (sol);
}
double sphere(double sol[])
{
int j;
double top=0;
for(j=0;j<D;j++)
{
top=top+sol[j]*sol[j];
}
return top;
}

double Rosenbrock(double sol[])
{
int j;
double top=0;
for(j=0;j<D-1;j++)
{
top=top+100*Math.pow((sol[j+1]-Math.pow((sol[j]),(double)2)),(double)2)+Math.pow((sol[j]-1),(double)2);
}
return top;
}

double Griewank(double sol[])
{
int j;
double top1,top2,top;
top=0;
top1=0;
top2=1;
for(j=0;j<D;j++)
{
top1=top1+Math.pow((sol[j]),(double)2);
top2=top2*Math.cos((((sol[j])/Math.sqrt((double)(j+1)))*Math.PI)/180);

}
top=(1/(double)4000)*top1-top2+1;
return top;
}

double Rastrigin(double sol[])
{
int j;
double top=0;

for(j=0;j<D;j++)
{
top=top+(Math.pow(sol[j],(double)2)-10*Math.cos(2*Math.PI*sol[j])+10);
}
return top;
}
}

使用方法是：
public class test {
static beeColony bee=new beeColony();

public static void main(String[] args) {
int iter=0;
int run=0;
int j=0;
double mean=0;
//srand(time(NULL));
for(run=0;run<bee.runtime;run++)
{
bee.initial();
bee.MemorizeBestSource();
for (iter=0;iter<bee.maxCycle;iter++)
{
bee.SendEmployedBees();
bee.CalculateProbabilities();
bee.SendOnlookerBees();
bee.MemorizeBestSource();
bee.SendScoutBees();
}
for(j=0;j<bee.D;j++)
{
//System.out.println("GlobalParam[%d]: %f\n",j+1,GlobalParams[j]);
System.out.println("GlobalParam["+(j+1)+"]:"+bee.GlobalParams[j]);
}
//System.out.println("%d. run: %e \n",run+1,GlobalMin);
System.out.println((run+1)+".run:"+bee.GlobalMin);
bee.GlobalMins[run]=bee.GlobalMin;
mean=mean+bee.GlobalMin;
}
mean=mean/bee.runtime;
//System.out.println("Means of %d runs: %e\n",runtime,mean);
System.out.println("Means of "+bee.runtime+"runs: "+mean);

}

}

⑻ dbcp连接池放回链接后再次拿出来地址为什么不一样，我只初始化一个。怎么打印判断两链接是同一个链接

1. 引入dbcp (选择1.4)

Java代码

为了能达到同样的效果，切换为spring dbcp配置时，也有类似密码加密的功能，运行期进行密码decode,最后进行数据链接。

实现方式很简单，分析jboss的对应SecureIdentityLoginMole的实现，无非就是走了Blowfish加密算法，自己拷贝实现一份。

⑼ 什么是RLE compression

Run-length_encoding compression

运行长度编码
From Wikipedia, the free encyclopedia维基网络，自由的网络全书

Run-length encoding ( RLE ) is a very simple form of data compression in which runs of data (that is, sequences in which the same data value occurs in many consecutive data elements) are stored as a single data value and count, rather than as the original run. 运行长度编码（RLE）是一个非常简单的表格数据压缩 ，其数据运行的（即，序列中相同的数据值的元素出现在许多连续的数据）比作为一个单一的数据存储和计算值，而作为原来运行。 This is most useful on data that contains many such runs: for example, relatively simple graphic images such as icons, line drawings, and animations.这是最的数据，其中包含许多这样的运行有用的：例如，如图标相对简单的图形图像，线条图和动画。 It is not useful with files that don't have many runs as it could potentially double the file size.这不是与文件有用，因为它没有可能的文件大小的两倍多运行。

RLE also refers to a little-used image format in Windows 3.x , with the extension .rle, which is a Run Length Encoded Bitmap, used to compress the Windows 3.1 startup screen.游程还提到使用的图像格式在小视窗3超延伸，与。游程编码，它是一个运行长度编码位图，使用压缩的Windows 3.1的启动画面。

For example, consider a screen containing plain black text on a solid white background.例如，考虑一个屏幕，其中包含了坚实的纯白色背景上的黑色文本。 There will be many long runs of white pixels in the blank space, and many short runs of black pixels within the text.将有许多白色长运行的像素的空白空间，黑色像素许多短期内运行的文本。 Let us take a hypothetical single scan line , with B representing a black pixel and W representing white:让我们以一个假设的单一扫描线 ，与B代表黑色像素和W代表白：

WWWWWWWWWWWW B WWWWWWWWWWWW BBB WWWWWWWWWWWWWWWWWWWWWWWW B WWWWWWWWWWWWWW WWWWWWWWWWWW 乙 WWWWWWWWWWWW 血脑屏障 WWWWWWWWWWWWWWWWWWWWWWWW 乙 WWWWWWWWWWWWWW

If we apply the run-length encoding (RLE) data compression algorithm to the above hypothetical scan line, we get the following:如果我们应用运行长度编码（RLE）的数据压缩算法，扫描线以上假设，我们得到以下几点：

12W1B12W3B24W1B14W
Interpret this as twelve W's, one B, twelve W's, three B's, etc.解释为12 W的，一架B，这12 W的，3个B的，等等

The run-length code represents the original 67 characters in only 18.在运行长度代码代表在原有67个字符只有18岁。 Of course, the actual format used for the storage of images is generally binary rather than ASCII characters like this, but the principle remains the same.当然，实际的图像格式用于存储二进制，而不是一般的ASCII字符喜欢这个，但原理是一样的。 Even binary data files can be compressed with this method; file format specifications often dictate repeated bytes in files as padding space.即使二进制数据文件可以被压缩使用此方法;文件格式规范，往往必须重复文件作为填充字节的空间。 However, newer compression methods such as DEFLATE often use LZ77 -based algorithms, a generalization of run-length encoding that can take advantage of runs of strings of characters (such as BWWBWWBWWBWW).然而，新的压缩方法，如紧缩经常使用的LZ77为基础的算法，一BWWBWWBWWBWW推广的运行长度编码，可以作为采取这种优势（运行的字符的字符串）。

Run-length encoding performs lossless data compression and is well suited to palette -based iconic images.运行长度编码进行数据压缩无损 ，是非常适合的调色板的标志性形象。 It does not work well at all on continuous-tone images such as photographs, although JPEG uses it quite effectively on the coefficients that remain after transforming and quantizing image blocks.它不工作，以及在所有图像连续色调，如照片，尽管JPEG格式使用改造后，它仍然是相当有效的系数的量化图像块。

Common formats for run-length encoded data include Truevision TGA , PackBits , PCX and ILBM .长度为通用格式编码的运行数据包括Truevision热重 ， PackBits ， PCX和ILBM 。

Run-length encoding is used in fax machines (combined with other techniques into Modified Huffman coding ).运行长度编码是用在传真技术结合到其他机器（ 改性哈夫曼编码 ）。 It is relatively efficient because most faxed documents are mostly white space, with occasional interruptions of black.这是比较有效，因为大多数的传真文件大多是白色的空间，黑色偶尔中断。

Data that have long sequential runs of bytes (such as lower-quality sound samples ) can be RLE compressed after applying a predictive filter such as delta encoding .已经运行的数据的字节长的顺序（如低质量的声音样本 ）可游程压缩在应用过滤器，如预测三角洲编码 。

⑽ 无线网络定位算法的程序。TOA/RSSI什么算法的都可以，想找个程序作个参考。

我有matlab的。
太多了，我的QQ：39400877

%|
%| SCRIPT: simMLE
%|
%| PURPOSE: Simulate a relative location system by generating
%| random measurements and maximizing the likelihood fcn.
%| After many trials, show the results vs. the Cramer-Rao Bound.
%|
%| AUTHOR: Neal Patwari
%| http://www.engin.umich.e/~npatwari/
%|
%| REFERENCE: Relative Location Estimation in Wireless Sensor Networks
%| (N. Patwari, A. O. Hero, M. Perkins, N. S. Correal, R. J. O'Dea),
%| IEEE Trans. Signal Processing, vol. 51, no. 8, Aug. 2003, pp. 2137-2148.
%|
tic

% Use globals to allow minimization functions access to network info,
% debugging info.
global refDevices blindDevices totalDevices linearRefLocs dhat funcEvals dfuncEvals;

% Basic simulation parameters
roomSize = [1,1]; % Room size, meters
gridSize = 5; % How many sensors per side
refDevices = 4; % How many references (must be same length as actualRefLocs)
trials = 20; % How many indep trials to run
measMethod = 'R'; % Use 'R' for RSS, 'T' for TOA
totalDevices = gridSize^2;
blindDevices = totalDevices - refDevices;
blindCoords = 2*blindDevices;
actualRefLocs = [0,0; 0,1; 1,1; 1,0];
linearRefLocs = [actualRefLocs(:,1)', actualRefLocs(:,2)'];

% Optimization parameters
ftol = 0.00001;
if measMethod == 'R',
func = 'calcError'; % Use for RSS
dfunc = 'calcDError'; % Use for RSS
else
func = 'calcErrorTOA'; % Use for TOA
dfunc = 'calcDErrorTOA'; % Use for TOA
end

%| 1. Set up the blindfolded device locations
delta = 1/(gridSize-1);
coords = 0:delta:1;
xMatrix = ones(gridSize,1)*coords;
yMatrix = xMatrix';
xBlind = [xMatrix(2:gridSize-1), ...
xMatrix(gridSize+1:totalDevices-gridSize), ...
xMatrix(totalDevices-gridSize+2:totalDevices-1)];
yBlind = [yMatrix(2:gridSize-1), ...
yMatrix(gridSize+1:totalDevices-gridSize), ...
yMatrix(totalDevices-gridSize+2:totalDevices-1)];
actualBlindLocs = [xBlind', yBlind'];
actualAllLocs = [actualRefLocs; actualBlindLocs];
xActual = actualAllLocs(:,1)';
yActual = actualAllLocs(:,2)';
actualDist = L2_distance(actualAllLocs', actualAllLocs',0);

%| 2. Define the channel model
if measMethod == 'R';
sigmaOverN = 1.7;
% If C==1, then this simulation runs the _true_ MLE.
% If C==exp( 0.5* (log(10)/10 *sigmaOverN)^2), then this runs a
% bias-corrected (pseudo-) MLE.
% C = exp( 0.5* (log(10)/10 *sigmaOverN)^2);
C = 1;
else
sigma_d = 0.2; % Use for TOA
end

for trial = 1:trials,

if measMethod == 'R';
%| 3.0 Generate a random set of RSS-based distance measurements. When RSS
%| is expressed in dB, errors are Gaussian. Here, dhat is an interim
%| variable which has units of distance, and represents an estimate for
%| the range. It is correctly randomly generated as follows:
dhat = actualDist.*10.^(sigmaOverN/10 .*symrandn(totalDevices))./C;
else
%| 3.1 Generate a set of TOA measurements, which are Gaussian around the
%| true value with variance sigma_d.
dhat = actualDist + sigma_d .* symrandn(totalDevices);
end

%| 4. Make an initial guess of the coordinates.
blindLocs0 = [xBlind, yBlind]; % Use the true coordinates (unrealistic but best case)

%| 5. Find optimum locations of neurfons (fixed and relative)
funcEvals = 0; dfuncEvals = 0;
[coordsMLE, iter, errorMin] = frprmn(blindLocs0, ftol, func, dfunc, 0);
disp(sprintf('%d: Function / Deriv. evals: %d / %d.', trial, funcEvals, dfuncEvals));

%| 6. Save the resulting estimated coords
coordEsts(trial, 1:blindCoords) = coordsMLE;
end % for trial

estMean = mean(coordEsts);
estCov = cov(coordEsts);
estVars = diag(estCov);
estStds = sqrt(estVars);
locVars = estVars(1:blindDevices) + estVars((blindDevices+1):(2*blindDevices));
locStd = sqrt(locVars);

toc % show time of execution

% Plot the location estimates for sensors, one at a time.
if 0,
figure
for i=1:blindDevices,
clf
plot(coordEsts(:,i), coordEsts(:,blindDevices+i),'.', ...
estMean(i), estMean(blindDevices+i), 'ro')
hold on
set(gca,'xlim',[-0.2 1.2])
set(gca,'ylim',[-0.2 1.2])
set(gca,'FontSize',20)
set(gca,'DataAspectRatio',[1 1 1])
xlabel('X Position (m)')
ylabel('Y Position (m)')
set(gca,'xTick',0:0.25:1)
set(gca,'yTick',0:0.25:1)
grid;
pause;
end
end

% Calculate and plot CRB vs. estimator performance.
figure; clf;
if measMethod == 'R';
[locstdCRB, coordCRB] = calcLocalizationCRB('R', [xBlind, actualRefLocs(:,1)'], ...
[yBlind, actualRefLocs(:,2)'], blindDevices, totalDevices, sigmaOverN);
else
[locstdCRB, coordCRB] = calcLocalizationCRB('T', [xBlind, actualRefLocs(:,1)'], ...
[yBlind, actualRefLocs(:,2)'], blindDevices, totalDevices, sigma_d);
end
for i=1:blindDevices,
hold on
R = cov(coordEsts(:,i), coordEsts(:,blindDevices+i));
drawOval(estMean(i), estMean(blindDevices+i), R, 'k-','v', 8, 0, 1);
R_CRB = coordCRB([i, i+blindDevices],[i, i+blindDevices]);
drawOval(xBlind(i), yBlind(i), R_CRB, 'r--','.',20, 0, 1);
end
set(gca,'xlim',[-0.2 1.2])
set(gca,'ylim',[-0.2 1.2])
set(gca,'FontSize',18)
set(gca,'DataAspectRatio',[1 1 1])
xlabel('X Position (m)')
ylabel('Y Position (m)')
set(gca,'xTick',0:0.25:1)
set(gca,'yTick',0:0.25:1)
grid;

% Use for comparison
RMS_est_Std = sqrt(mean(locStd.^2))
RMS_crb_Std = sqrt(mean(locstdCRB.^2))