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))