stl加密演算法

㈠ STL的演算法

大家都能取得的一個共識是函數庫對數據類型的選擇對其可重用性起著至關重要的作用。舉例來說，一個求方根的函數，在使用浮點數作為其參數類型的情況下的可重用性肯定比使用整型作為它的參數類型要高。而C++通過模板的機制允許推遲對某些類型的選擇，直到真正想使用模板或者說對模板進行特化的時候，STL就利用了這一點提供了相當多的有用演算法。它是在一個有效的框架中完成這些演算法的——你可以將所有的類型劃分為少數的幾類，然後就可以在模版的參數中使用一種類型替換掉同一種類中的其他類型。
STL提供了大約100個實現演算法的模版函數，比如演算法for_each將為指定序列中的每一個元素調用指定的函數，stable_sort以你所指定的規則對序列進行穩定性排序等等。這樣一來，只要我們熟悉了STL之後，許多代碼可以被大大的化簡，只需要通過調用一兩個演算法模板，就可以完成所需要的功能並大大地提升效率。
演算法部分主要由頭文件<algorithm>，<numeric>和<functional>組成。<algorithm>是所有STL頭文件中最大的一個（盡管它很好理解），它是由一大堆模版函數組成的，可以認為每個函數在很大程度上都是獨立的，其中常用到的功能范圍涉及到比較、交換、查找、遍歷操作、復制、修改、移除、反轉、排序、合並等等。<numeric>體積很小，只包括幾個在序列上面進行簡單數學運算的模板函數，包括加法和乘法在序列上的一些操作。<functional>中則定義了一些模板類，用以聲明函數對象。

㈡ stl演算法中sort如果第三個參數為一個string類型的數據會是什麼情況

不會排序的！通過不了！
2個參數的，要求要麼普通數據類型，要麼重載<運算符
3個參數的，要求第三個參數是返回bool類型的函數指針！

㈢ djstl演算法

定義Dijkstra(迪傑斯特拉)演算法是典型的單源最短路徑演算法，用於計算一個節點到其他所有節點的最短路徑。主要特點是以起始點為中心向外層層擴展，直到擴展到終點為止。Dijkstra演算法是很有代表性的最短路徑演算法，在很多專業課程中都作為基本內容有詳細的介紹，如數據結構，圖論，運籌學等等。Dijkstra一般的表述通常有兩種方式，一種用永久和臨時標號方式，一種是用OPEN,
CLOSE表的方式，這里均採用永久和臨時標號的方式。注意該演算法要求圖中不存在負權邊。
問題描述在無向圖
G=(V,E) 中，假設每條邊 E[i] 的長度為 w[i]，找到由頂點 V0 到其餘各點的最短路徑。（單源最短路徑）

編輯本段迪傑斯特拉演算法迪傑斯特拉(Dijkstra)演算法思想
按路徑長度遞增次序產生最短路徑演算法：

把V分成兩組：

（1）S：已求出最短路徑的頂點的集合

（2）V-S=T：尚未確定最短路徑的頂點集合

將T中頂點按最短路徑遞增的次序加入到S中，

保證：（1）從源點V0到S中各頂點的最短路徑長度都不大於

從V0到T中任何頂點的最短路徑長度

（2）每個頂點對應一個距離值

S中頂點：從V0到此頂點的最短路徑長度

T中頂點：從V0到此頂點的只包括S中頂點作中間

頂點的最短路徑長度

依據：可以證明V0到T中頂點Vk的最短路徑，或是從V0到Vk的

直接路徑的權值；或是從V0經S中頂點到Vk的路徑權值之和

（反證法可證）

求最短路徑步驟
演算法步驟如下：

1. 初使時令 S={V0},T={其餘頂點}，T中頂點對應的距離值

若存在<V0,Vi>，d(V0,Vi)為<V0,Vi>弧上的權值

若不存在<V0,Vi>，d(V0,Vi)為∝

2. 從T中選取一個其距離值為最小的頂點W且不在S中，加入S

3. 對S中頂點的距離值進行修改：若加進W作中間頂點，從V0到Vi的

距離值縮短，則修改此距離值

重復上述步驟2、3，直到S中包含所有頂點，即W=Vi為止

編輯本段迪傑斯特拉演算法的原理首先，引進一個輔助向量D，它的每個分量D表示當前所找到的從始點v到每個終點vi的最短路徑的長度。如D[3]=2表示從始點v到終點3的路徑相對最小長度為2。這里強調相對就是說在演算法過程中D的值是在不斷逼近最終結果但在過程中不一定就等於最短路徑長度。它的初始狀態為：若從v到vi有弧，則D為弧上的權值；否則置D為∞。顯然，長度為
D[j]=Min{D | vi∈V} 的路徑就是從v出發的長度最短的一條最短路徑。此路徑為(v,vj)。
那麼，下一條長度次短的最短路徑是哪一條呢？假設該次短路徑的終點是vk，則可想而知，這條路徑或者是(v,vk)，或者是(v,vj,vk)。它的長度或者是從v到vk的弧上的權值，或者是D[j]和從vj到vk的弧上的權值之和。
一般情況下，假設S為已求得最短路徑的終點的集合，則可證明：下一條最短路徑（設其終點為X）或者是弧(v,x)，或者是中間只經過S中的頂點而最後到達頂點X的路徑。因此，下一條長度次短的最短路徑的長度必是D[j]=Min{D
| vi∈V-S} 其中，D或者是弧(v,vi)上的權值，或者是D[k](vk∈S)和弧(vk,vi)上的權值之和。 迪傑斯特拉演算法描述如下：
1）arcs表示弧上的權值。若不存在，則置arcs為∞（在本程序中為MAXCOST）。S為已找到從v出發的最短路徑的終點的集合，初始狀態為空集。那麼，從v出發到圖上其餘各頂點vi可能達到的最短路徑長度的初值為D=arcs[Locate
Vex(G,v),i] vi∈V 2）選擇vj，使得D[j]=Min{D | vi∈V-S} 3）修改從v出發到集合V-S上任一頂點vk可達的最短路徑長度。

編輯本段迪傑斯特拉演算法C#程序public class Edge

{

public string StartNodeID ;

public string EndNodeID ;

public double Weight ; //權值，代價

} 節點則抽象成Node類，一個節點上掛著以此節點作為起點的「出邊」表。

public class Node

{

private string iD ;

private ArrayList edgeList ;//Edge的集合－－出邊表

public Node(string id )

{

this.iD = id ;

this.edgeList = new ArrayList() ;

}

property#region property

public string ID

{

get

{

return this.iD ;

}

}

public ArrayList EdgeList

{

get

{

return this.edgeList ;

}

}

#endregion

}

在計算的過程中，我們需要記錄到達每一個節點權值最小的路徑，這個抽象可以用PassedPath類來表示：

/// <summary>

/// PassedPath 用於緩存計算過程中的到達某個節點的權值最小的路徑

/// </summary>

public class PassedPath

{

private string curNodeID ;

private bool beProcessed ; //是否已被處理

private double weight ; //累積的權值

private ArrayList passedIDList ; //路徑

public PassedPath(string ID)

{

this.curNodeID = ID ;

this.weight = double.MaxValue ;

this.passedIDList = new ArrayList() ;

this.beProcessed = false ;

}

#region property

public bool BeProcessed

{

get

{

return this.beProcessed ;

}

set

{

this.beProcessed = value ;

}

}

public string CurNodeID

{

get

{

return this.curNodeID ;

}

}

public double Weight

{

get

{

return this.weight ;

}

set

{

this.weight = value ;

}

}

public ArrayList PassedIDList

{

get

{

return this.passedIDList ;

}

}

#endregion

}

另外，還需要一個表PlanCourse來記錄規劃的中間結果，即它管理了每一個節點的PassedPath。

/// <summary>

/// PlanCourse 緩存從源節點到其它任一節點的最小權值路徑=》路徑表

/// </summary>

public class PlanCourse

{

private Hashtable htPassedPath ;

#region ctor

public PlanCourse(ArrayList nodeList ,string originID)

{

this.htPassedPath = new Hashtable() ;

Node originNode = null ;

foreach(Node node in nodeList)

{

if(node.ID == originID)

{

originNode = node ;

}

else

{

PassedPath pPath = new PassedPath(node.ID) ;

this.htPassedPath.Add(node.ID ,pPath) ;

}

}

if(originNode == null)

{

throw new Exception("The origin node is not exist !")
;

}

this.InitializeWeight(originNode) ;

}

private void InitializeWeight(Node originNode)

{

if((originNode.EdgeList == null)
||(originNode.EdgeList.Count == 0))

{

return ;

}

foreach(Edge edge in originNode.EdgeList)

{

PassedPath pPath = this[edge.EndNodeID] ;

if(pPath == null)

{

continue ;

}

pPath.PassedIDList.Add(originNode.ID) ;

pPath.Weight = edge.Weight ;

}

}

#endregion

public PassedPath this[string nodeID]

{

get

{

return (PassedPath)this.htPassedPath[nodeID] ;

}

}

}

在所有的基礎構建好後，路徑規劃演算法就很容易實施了，該演算法主要步驟如下：

(1)用一張表(PlanCourse)記錄源點到任何其它一節點的最小權值，初始化這張表時，如果源點能直通某節點，則權值設為對應的邊的權，否則設為double.MaxValue。

(2)選取沒有被處理並且當前累積權值最小的節點TargetNode，用其邊的可達性來更新到達其它節點的路徑和權值（如果其它節點
經此節點後權值變小則更新，否則不更新），然後標記TargetNode為已處理。

(3)重復(2)，直至所有的可達節點都被處理一遍。

(4)從PlanCourse表中獲取目的點的PassedPath，即為結果。

下面就來看上述步驟的實現，該實現被封裝在RoutePlanner類中：

/// <summary>

/// RoutePlanner 提供圖演算法中常用的路徑規劃功能。

/// 2005.09.06

/// </summary>

public class RoutePlanner

{

public RoutePlanner()

{

}

#region Paln

//獲取權值最小的路徑

public RoutePlanResult Paln(ArrayList nodeList ,string
originID ,string destID)

{

PlanCourse planCourse = new PlanCourse(nodeList
,originID) ;

Node curNode = this.GetMinWeightRudeNode(planCourse
,nodeList ,originID) ;

#region 計算過程

while(curNode != null)

{

PassedPath curPath = planCourse[curNode.ID] ;

foreach(Edge edge in curNode.EdgeList)

{

PassedPath targetPath = planCourse[edge.EndNodeID] ;

double tempWeight = curPath.Weight + edge.Weight ;

if(tempWeight < targetPath.Weight)

{

targetPath.Weight = tempWeight ;

targetPath.PassedIDList.Clear() ;

for(int i=0 ;i<curPath.PassedIDList.Count ;i++)

{

targetPath.PassedIDList.Add(curPath.PassedIDList.ToString())
;

}

targetPath.PassedIDList.Add(curNode.ID) ;

}

}

//標志為已處理

planCourse[curNode.ID].BeProcessed = true ;

//獲取下一個未處理節點

curNode = this.GetMinWeightRudeNode(planCourse
,nodeList ,originID) ;

}

#endregion

//表示規劃結束

return this.GetResult(planCourse ,destID) ;

}

#endregion

#region private method

#region GetResult

//從PlanCourse表中取出目標節點的PassedPath，這個PassedPath即是規劃結果

private RoutePlanResult GetResult(PlanCourse
planCourse ,string destID)

{

PassedPath pPath = planCourse[destID] ;

if(pPath.Weight == int.MaxValue)

{

RoutePlanResult result1 = new RoutePlanResult(null
,int.MaxValue) ;

return result1 ;

}

string[] passedNodeIDs = new
string[pPath.PassedIDList.Count] ;

for(int i=0 ;i<passedNodeIDs.Length ;i++)

{

passedNodeIDs = pPath.PassedIDList.ToString() ;

}

RoutePlanResult result = new
RoutePlanResult(passedNodeIDs ,pPath.Weight) ;

return result ;

}

#endregion

#region GetMinWeightRudeNode

//從PlanCourse取出一個當前累積權值最小，並且沒有被處理過的節點

private Node GetMinWeightRudeNode(PlanCourse
planCourse ,ArrayList nodeList ,string originID)

{

double weight = double.MaxValue ;

Node destNode = null ;

foreach(Node node in nodeList)

{

if(node.ID == originID)

{

continue ;

}

PassedPath pPath = planCourse[node.ID] ;

if(pPath.BeProcessed)

{

continue ;

}

if(pPath.Weight < weight)

{

weight = pPath.Weight ;

destNode = node ;

}

}

return destNode ;

}

#endregion

#endregion

}

編輯本段迪傑斯特拉演算法pascal程序type bool=array[1..10]of
boolean;

arr=array[0..10]of integer;

var a:array[1..10,1..10]of integer;
//存儲圖的鄰接數組，無邊為10000

c,d,e:arr; //c為最短路徑數值,d為各點前趨,

t:bool; //e：路徑，t為輔助數組

i,j,n,m:integer;

inf,outf:text;

////////////////////////////////////////////////////////////////////////////////

procere init; //不同題目鄰接數組建立方式不一樣

begin

assign(inf,'dijkstra.in');
assign(outf,'dijkstra.out');

reset(inf); rewrite(outf);

read(inf,n);

for i:=1 to n do

for j:=1 to n do

begin

read(inf,a[i,j]);

if a[i,j]=0 then a[i,j]:=10000;

end;

end;

////////////////////////////////////////////////////////////////////////////////

procere dijkstra(qi:integer; t:bool; var c{,d}:arr);
//qi起點，{}中為求路徑部

var i,j,k,min:integer; //分,不需求路徑時可以不要

begin //t數組一般在調用前初始

t[qi]:=true; //化成false,也可將部分點

{for i:=1 to n do d[i]:=qi; d[qi]:=0; }
//初始化成true以迴避這些點

for i:=1 to n do c[i]:=a[qi,i];

for i:=1 to n-1 do

begin

min:=10001;

for j:=1 to n do

if (c[j]<min)and(not(t[j])) then begin k:=j;
min:=c[j];end;

t[k]:=true;

for j:=1 to n do

if (c[k]+a[k,j]<c[j])and(not(t[j])) then

begin

c[j]:=c[k]+a[k,j]; {d[j]:=k;}

end;

end;

end;

////////////////////////////////////////////////////////////////////////////////

procere make(zh:integer; d:arr; var e:arr);
//生成路徑,e[0]保存路徑

var i,j,k:integer; //上的節點個數

begin

i:=0;

while d[zh]<>0 do

begin

inc(i);e[i]:=zh;zh:=d[zh];

end;

inc(i);e[i]:=qi; e[0]:=I;

end;

主程序調用：求最短路徑長度：初始化t，然後dijkstra(qi,t,c,d)

求路徑：make(m,d,e) ，m是終點

編輯本段Dijkstra演算法的堆優化(PASCAL實現)一、思考
我們可以發現，在實現步驟時，效率較低(需要O(n)，使總復雜度達到O(n^2)。對此可以考慮用堆這種數據結構進行優化，使此步驟復雜度降為O(log(n))(總復雜度降為O(n
log(n))。

二、實現
1. 將與源點相連的點加入堆，並調整堆。
2. 選出堆頂元素u（即代價最小的元素），從堆中刪除，並對堆進行調整。
3. 處理與u相鄰的，未被訪問過的，滿足三角不等式的頂點
1):若該點在堆里，更新距離，並調整該元素在堆中的位置。
2):若該點不在堆里，加入堆，更新堆。
4. 若取到的u為終點，結束演算法；否則重復步驟2、3。
三、代碼
procere Dijkstra;

var

u,v,e,i:longint;

begin

fillchar(dis,sizeof(dis),$7e); //距離

fillchar(Inh,sizeof(Inh),false); //是否在堆中

fillchar(visit,sizeof(visit),false); //是否訪問過

size:=0;

e:=last[s];

while e<>0 do //步驟1

begin

u:=other[e];

if not(Inh[u]) then //不在堆里

begin

inc(size);

heap[size]:=u;

dis[u]:=cost[e];

Loc[u]:=size; //Loc數組記錄元素在堆中的位置

Inh[u]:=true;

Shift_up(Loc[u]); //上浮

end

else

if cost[e]<dis[u] then //在堆里

begin

dis[u]:=cost[e];

Shift_up(Loc[u]);

Shift_down(Loc[u]);

end;

e:=pre[e];

end;

visit[s]:=true;

while true do

begin

u:=heap[1]; //步驟2

if u=t then break; //步驟4

visit[u]:=true;

heap[1]:=heap[size];

dec(size);

Shift_down(1);

e:=last[u];

while e<>0 do //步驟3

begin

v:=other[e];

if Not(visit[v]) and (dis[u]+cost[e]<dis[v]) then
//與u相鄰的，未被訪問過的，滿足三角不等式的頂點

if Inh[v] then //在堆中

begin

dis[v]:=dis[u]+cost[e];

Shift_up(Loc[v]);

Shift_Down(Loc[v]);

end

else //不再堆中

begin

inc(size);

heap[size]:=v;

dis[v]:=dis[u]+cost[e];

Loc[v]:=size;

Inh[v]:=true;

Shift_up(Loc[v]);

end;

e:=pre[e];

end;

end;

writeln(dis[t]);

end;
http://ke..com/view/7839.htm

http://ke..com/view/1939816.htm

㈣ 簡述stl格式的優缺點

STL優點：

代碼易讀性強；

STL集成了優秀的演算法，熟悉使用可以提高開發效率；
精通STL後，可以自己用模板去設計實現自己的演算法和數據結構。

STL缺點：

STL和其他的類庫的介面不太方便。
例如在VCL和MFC中，都有自己的string類型，CString和AnsiString，其餘介面如果使用字元串，肯定是使用自己的原生類型，然而為了設計可移植的程序，有可能將平台獨立的部分用STL實現，這樣導致了在兩部分合作時存在大量的轉型動作，而且必須付出額外的轉型動作，例如std::string和CString/AnsiString沒有直接的轉型方法，因此必須通過char *作為轉型的媒介。

㈤ STL 演算法問題

IsAToothbrush 是函數對象（function object)，如果可以，關於這個概念還是建議你翻一下手頭的書，你就明白了。函數對象的定義就是一個類重載了()運算符，而函數count_if 需要一個函數對象（我對stl也不完全了解，不知道這里傳一個函數指針是不是也是可以的，但是例子裡面用的是函數對象），這個對象的作用就是 count_if函數執行的時候，會遍歷集合的元素，用調用operator()來判斷是否要刪除某個元素

㈥ STL中的演算法是對所有容器都適用嗎

c++ stl 標准模板庫 c++容器類vector . 向量容器deque 雙端隊列容器list 雙向鏈表容器slist 單向鏈表容器bit_vector 位向量容器set 集合容器multiset 多重集合容器map 映照容器multimap 多重映照容器hash_set 哈希集合容器hash_map 哈希映照容器string 基本字元序列容器stack 堆棧容器queue 隊列容器priority_queue 優先隊列容器 c++stl 演算法 逐個容器元素 for_each查找容器元素 find 條件查找 find_if鄰近查找容器 adjacent_find范圍查找容器元素 find_first_of統計等於某值的容器元素個數 count條件統計 count_if..這里還有很多很多 演算法 其中比較有用的sort 排序stable_sort 穩定排序反向元素 reverse旋轉 rotate

㈦ 表明feistel解密是加密的逆feistl

主要還是Feistel網路的求逆,可以去看看Feistel結構。不懂再一起討論討論~

㈧ STL是什麼意思

什麼是STL呢？STL就是Standard
Template
Library，標准模板庫。這可能是一個歷史上最令人興奮的工具的最無聊的術語。從根本上說，STL是一些「容器」的集合，這些「容器」有list,vector,set,map等，STL也是演算法和其他一些組件的集合。這里的「容器」和演算法的集合指的是世界上很多聰明人很多年的傑作。
STL的目的是標准化組件，這樣就不用重新開發，可以使用現成的組件。STL現在是C++的一部分，因此不用額外安裝什麽。它被內建在你的編譯器之內。因為STL的list是一個簡單的容器，所以我打算從它開始介紹STL如何使用。如果你懂得了這個概念，其他的就都沒有問題了。另外，list容器是相當簡單的，我們會看到這一點。
在本文中我們將會看到如何定義和初始化一個list，計算它的元素的數量，從一個list里查找元素，刪除元素，和一些其他的操作。要作到這些，我們將會討論兩個不同的演算法，STL通用演算法都是可以操作不止一個容器的，而list的成員函數是list容器專有的操作。
這是三類主要的STL組件的簡明綱要。STL容器可以保存對象，內建對象和類對象。它們會安全的保存對象，並定義我們能夠操作的這個對象的介面。放在蛋架上的雞蛋不會滾到桌上。它們很安全。因此，在STL容器中的對象也很安全。我知道這個比喻聽起來很老土，但是它很正確。
STL演算法是標准演算法，我們可以把它們應用在那些容器中的對象上。這些演算法都有很著名的執行特性。它們可以給對象排序，刪除它們，給它們記數，比較，找出特殊的對象，把它們合並到另一個容器中，以及執行其他有用的操作。
http://www.yesky.com/255/1910755.shtml
還有一種解釋：
什麼是STL？
STL代表科學和技術素養，但這個短語的背後隱藏的重要意義是對所有人而言。
STL也許可以簡單地視為一個哲學觀點，但決不僅僅如此。它包括了一套完整的教育方法,這個方法包含生活中的科學技術和不僅是學校師生的還有普通市民和政治家在內的所有人的思想。
為了達到普及科學技術的要求，科學技術的排它性和教師\科學家對科學教育的態度要根本轉變。
課堂中的科學教育要從教師為主導、以教學大綱為核心的教育方式中解脫出來，代之以學生為中心來設計、指導和進行組織教學。為了使學生全身心投入學習動機是非常重要的而且這將只有在科學技術成為學生日常生活的需要時才能得到激發。
考慮到這些，我們現在是現代世界的一部分，這種意識比以前更為強烈，知識的獲取與事實的記憶日益無關。一個微型行動電話能夠直接接入網際網路。這是能夠在我們的指尖表達出一些事實信息。結果是學生在大量的事實學習（這是很快過時的知識）的思維負擔是明顯無意義的。
一旦這些負擔被減輕了，全體學生親自感受科學和技術的潛能就能被發掘出來。科學和技術不再被看作僅僅是』最聰明的』學生的寶貝。批判性思維得到解放。這些能揭示挑戰不可靠信息和無確實根據的個人觀點的思維方法，不管這些觀點是來自』專家』，還是廣告代理商或者政治家們。
現存的許多科學技術的排它性營造了道德和價值觀來自於藝術和人文的氛圍。實際上許多當前

㈨ STL是什麼

STL是司太立合金的簡稱

司太立（Stellite）是一種能耐各種類型磨損和腐蝕以及高溫氧化的硬質合金。即通常所說的鈷基合金，司太立合金由美國人Elwood Hayness 於1907年發明。司太立合金是以鈷作為主要成分，含有相當數量的鎳、鉻、鎢和少量的鉬、鈮、鉭、鈦、鑭等合金元素，偶而也還含有鐵的一類合金。根據合金中成分不同，它們可以製成焊絲，粉末用於硬面堆焊，熱噴塗、噴焊等工藝，也可以製成鑄鍛件和粉末冶金件。

司太立合金鑄件適用於核電、石化、電力、電池、玻璃、輕工、食品等諸多領域。具有耐磨、耐蝕、抗氧化和耐高溫特性。常用的產品有閥芯、閥座、軸類、軸套、泵類部件，玻璃、電池模具、噴嘴及切割刀具等。合金類別有：Co基合金鑄件、Ni基合金鑄件、Fe基合金鑄件。司太立粉末冶金製品採用鈷基、鎳基或鐵基合金霧化粉末，經壓制、燒結、精加工製成。主要產品有閥桿、閥芯（球）、閥座、閥圈、密封環、木材鋸齒、軸承泵、軸承球等。