算法模版

① c/c++ 最大流算法ford-fulkerson

你的问题是用C/C++写最大流算法ford-fulkerson算法。顶点就是节点。

void maximum_flow(int n, int s, int t, int *capacity, int *flow)

可以参考：算法模板-最大流（Ford-fulkerson算法）

② 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也许可以简单地视为一个哲学观点，但决不仅仅如此。它包括了一套完整的教育方法,这个方法包含生活中的科学技术和不仅是学校师生的还有普通市民和政治家在内的所有人的思想。
为了达到普及科学技术的要求，科学技术的排它性和教师\科学家对科学教育的态度要根本转变。
课堂中的科学教育要从教师为主导、以教学大纲为核心的教育方式中解脱出来，代之以学生为中心来设计、指导和进行组织教学。为了使学生全身心投入学习动机是非常重要的而且这将只有在科学技术成为学生日常生活的需要时才能得到激发。
考虑到这些，我们现在是现代世界的一部分，这种意识比以前更为强烈，知识的获取与事实的记忆日益无关。一个微型移动电话能够直接接入因特网。这是能够在我们的指尖表达出一些事实信息。结果是学生在大量的事实学习（这是很快过时的知识）的思维负担是明显无意义的。
一旦这些负担被减轻了，全体学生亲自感受科学和技术的潜能就能被发掘出来。科学和技术不再被看作仅仅是’最聪明的’学生的宝贝。批判性思维得到解放。这些能揭示挑战不可靠信息和无确实根据的个人观点的思维方法，不管这些观点是来自’专家’，还是广告代理商或者政治家们。
现存的许多科学技术的排它性营造了道德和价值观来自于艺术和人文的氛围。实际上许多当前

③ ACM：参加过ACM的大牛是不是练习时都要把每个算法敲几十几百次呢

ACM比赛可以带纸质资料，准备一份模板是很有必要的，所以算法模版很重要，记住模版一定要权威，不要网上杂七杂八的拿来当模版，一份好的模板一定会对你的编程习惯和算法实现打下良好的基础。但是，ACM比赛的等级越高，模版的作用就越小，毕竟比赛不是套模板。

没有人会把每个算法敲几百遍，大牛更加不会，敲十遍还记不住的话，一百遍也没用的，重要的是对算法本身的理解。如果你真正理解了算法但写不出来，那是你编程水平问题，这样应该多看看大牛的代码，多看看模板。
大牛不是算法模板敲的多，而是对算法理解的深刻并加上做的题目多，算法就像数学公式，你记住公式难道就能考高分了吗。重要的是运用啊，一个数学高手对于新学的公式他可以随时推导出来，因为对公式真正理解啊，推的多了自然记住了，不是吗。对于新手，先不要学算法，先去poj做水题，就是简单的题目没什么算法，水题不要做太多，100题就差不多了。接下来就该系统的学习一下算法了，《算法导论》和《算法艺术与信息学竞赛》是我觉得必看的两本书。另外，历届NOI国家队选手的论文也是很有价值的，也属于必看。接下来继续去poj做题，多思考，做不出来就网络，google，poj做题的人非常多。做题可以查漏补缺，之前没碰到过的 算法都可能在题目中体现，碰到没学过的算法就网络学习，然后选一个好的放到你的算法模板库，poj做题1000以上想不成大牛都难！

我只想说大牛基本上都是这么过来的，当然不排除个别天才，不过我没碰到过也没听过谁不做大量的题就能成为牛人的，毕竟天道酬勤。

④ 什么叫模板

您好。“模板”是对使东西达到标准化、统一化、模式化的通用，或固定格式、版式的统称。一种是指平时生活中，我们统一套用的格式、版式，例如PPT、word、海报等等。还有一种是建筑模板，是使物体成固定型状的模具，也是新浇混凝土成型用的模型。常用的模板包括木模板、定型组合模板等等。中鑫绿建超强复合模板，是在建筑领域使用率最高，周转次数最高，回收率最高的建筑模板。希望我的回答能帮助到您。

⑤ 求此程序！在线等，急！

Tarjan 算法

一.算法简介

Tarjan 算法一种由Robert Tarjan提出的求解有向图强连通分量的算法，它能做到线性时间的复杂度。

我们定义：

如果两个顶点可以相互通达，则称两个顶点强连通(strongly connected)。如果有向图G的每两个顶点都强连通，称G是一个强连通图。有向图的极大强连通子图，称为强连通分量(strongly connected components)。

1 void Tarjan ( int x ) { 2 dfn[ x ] = ++dfs_num ; 3 low[ x ] = dfs_num ; 4 vis [ x ] = true ;//是否在栈中 5 stack [ ++top ] = x ; 6 for ( int i=head[ x ] ; i!=0 ; i=e[i].next ){ 7 int temp = e[ i ].to ; 8 if ( !dfn[ temp ] ){ 9 Tarjan ( temp ) ;10 low[ x ] = gmin ( low[ x ] , low[ temp ] ) ;11 }12 else if ( vis[ temp ])low[ x ] = gmin ( low[ x ] , dfn[ temp ] ) ;13 }14 if ( dfn[ x ]==low[ x ] ) {//构成强连通分量15 vis[ x ] = false ;16 color[ x ] = ++col_num ;//染色17 while ( stack[ top ] != x ) {//清空18 color [stack[ top ]] = col_num ;19 vis [ stack[ top-- ] ] = false ;20 }21 top -- ;22 }23 }

⑥ 土建模板工程量怎么计算柱，梁，板，都怎么算求详细点的算法，公式…

土建模板工程量为柱，梁，板等构件量的总和。计算公式：垫层模板：S=1*4*0.1*2=0.8m2(周长 X 高 X 个数)，基础模板：S=0.8*4*0.45*2=2.89m2（周长 X 高 X 个数）。

基础柱模板：S=（0.4*4*0.6-0.4*0.3*2）*2=1.44m2（（周长 X 高 - 梁头接触部位面积）X 个数），梁模板：S=(0.3+0.4*2)*(4-0.2*2)=3.96m2（（底面 + 侧面 X 2) X 梁净长）。

在计算板底肋梁的时候，板底肋梁的模板计算高度为：梁截面高度--现浇板高度，故而出现楼主所说的同学在计算梁的模板的时候，扣除120（这个扣除的高度要看现浇板的厚度）。

着重一点：在现浇板外围的梁模板要计算全高，比如上面的，外围梁模板高度为0.4m，靠梁内侧高度为0.4-0.12=0.28m。

(6)算法模版扩展阅读：

建筑模板是一种临时性支护结构，按设计要求制作，使混凝土结构、构件按规定的位置、几何尺寸成形，保持其正确位置，并承受建筑模板自重及作用在其上的外部荷载，进行模板工程的目的，是保证混凝土工程质量与施工安全、加快施工进度和降低工程成本。

参考资料来源：网络-建筑模板

⑦ STL的算法

大家都能取得的一个共识是函数库对数据类型的选择对其可重用性起着至关重要的作用。举例来说，一个求方根的函数，在使用浮点数作为其参数类型的情况下的可重用性肯定比使用整型作为它的参数类型要高。而C++通过模板的机制允许推迟对某些类型的选择，直到真正想使用模板或者说对模板进行特化的时候，STL就利用了这一点提供了相当多的有用算法。它是在一个有效的框架中完成这些算法的——你可以将所有的类型划分为少数的几类，然后就可以在模版的参数中使用一种类型替换掉同一种类中的其他类型。
STL提供了大约100个实现算法的模版函数，比如算法for_each将为指定序列中的每一个元素调用指定的函数，stable_sort以你所指定的规则对序列进行稳定性排序等等。这样一来，只要我们熟悉了STL之后，许多代码可以被大大的化简，只需要通过调用一两个算法模板，就可以完成所需要的功能并大大地提升效率。
算法部分主要由头文件<algorithm>，<numeric>和<functional>组成。<algorithm>是所有STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。<functional>中则定义了一些模板类，用以声明函数对象。

⑧ 求KM算法模板pascal源代码 n3的复杂度

POJ2400（标准KM算法）
题目大意：有n个管理员需要雇佣n个工作人员。 每个管理员对每个工作人员的评价不同，评价值(score)从0-n-1，0代表评价最高，n-1代表评价最低，同样，每个工作人员对每个管理员也有不同 的评价，评价值也是从0-n-1，0代表评价值最高，n-1代表最低。问n个管理员怎样选择n个工作人员可以使的每个人的平均评价值最小。即总的评价值 /（2*n）最小。如果存在多种最佳方案，则按照字典序输出每一种情况。

代码：
program p2400;
const maxn=100;
var i,j,k,n,m,t,max,z:longint; ok:boolean; ans:real;
p,dist:array[1..15,1..15]of longint;
a,b,slake,link,emp:array[1..15]of longint;
ah,bh:array[1..15]of boolean;
function min(a,b:longint):longint;
begin
if a<b then exit(a); exit(b);
end;
function find(v:longint):boolean;
var i:longint;
begin
ah[v]:=true;
for i:=1 to n do
begin
if not(bh[i])and(dist[v,i]=a[v]+b[i]) then
begin
bh[i]:=true;
if(link[i]=0)or(find(link[i]))then
begin
link[i]:=v;
exit(true);
end;
end else
if dist[v,i]<a[v]+b[i] then slake[v]:=min(slake[v],a[v]+b[i]-dist[v,i]);
end;
exit(false);
end;
procere print;
var i:longint;
begin
inc(z);
writeln('Best Pairing ',z);
for i:=1 to n do
writeln('Supervisor ',i,' with Employee ',emp[i]);
end;
procere dfs(k:longint);
var i:longint;
begin
for i:=1 to n do
if ah[i] then
begin
inc(t,dist[k,i]);
if t>max then begin dec(t,dist[k,i]);exit; end;
ah[i]:=false; emp[k]:=i;
if k<>n then dfs(k+1)
else print;
ah[i]:=true; dec(t,dist[k,i]);
end;
end;
begin
assign(input,'p2400.in');reset(input);
assign(output,'p2400.out');rewrite(output);
readln(m);
for k:=1 to m do
begin
fillchar(a,sizeof(a),0);
fillchar(b,sizeof(b),0);
fillchar(dist,sizeof(dist),0);
fillchar(link,sizeof(link),0);
read(n);
for i:=1 to n do
for j:=1 to n do
begin read(t); dist[i,t]:=j-1; end;
for i:=1 to n do
for j:=1 to n do
begin read(t); inc(dist[t,i],j-1); end;
for i:=1 to n do
for j:=1 to n do
begin
dist[i,j]:=maxn-dist[i,j];
if dist[i,j]>a[i] then a[i]:=dist[i,j];
end;
for i:=1 to n do
repeat
fillchar(ah,sizeof(ah),false);
fillchar(bh,sizeof(bh),false);
fillchar(slake,sizeof(slake),$3f);
ok:=find(i);
if not(ok) then
begin
t:=maxlongint;
for j:=1 to n do t:=min(t,slake[j]);
for j:=1 to n do
begin
if ah[j] then dec(a[j],t);
if bh[j] then inc(b[j],t);
end;
end;
until ok;
max:=0; ans:=0; t:=0; z:=0;
for i:=1 to n do
begin
max:=max+a[i];
max:=max+b[i];
end;
max:=maxn*n-max;
ans:=max/(n shl 1);
writeln('Data Set ',k,', Best average difference: ',ans:0:6);
fillchar(ah,sizeof(ah),true);
for i:=1 to n do
for j:=1 to n do
dist[i,j]:=maxn-dist[i,j];
dfs(1);
writeln;
end;
close(input);close(output);
end.

⑨ 舍伍德算法的4用类模板实现算法

用类模板实现的算法如下：
template<classType>
boolCOrderlist<Type>：：Search(Type x, int&index)
//搜索有序链袭中的指定元素x、并将其位置放在index变量中
{//mCnrrentNumber为当前有序链表中元素的个数，它为类模
//板CorderLisl的数据成员,m为随机搜索的次数；
int m=(int)sqrt(double(m_CurmntNumber));
int j;
index=O;
//m_LowBound为当前有序链表中最小元素的值．它为类模板
//CorderList的数据成员;
Type max=m_LowBound;
for(int i=l；i<=m，i++}
{j=randl();
//产生一个随机数j，在数组m_pData[]随机中找一个值
Type y-m—pDataU]：
If((max<y)&&(y<x))
//找最靠近查找元素x的索引位置Index
{max=y；
index=j；}
}
//从最靠近查找元素x的Index所指向的位置升妯进行顺序搜索
while(m_pData[m_pLink[index]]<x)
index=m_pLink[index]；∥指针后移
return(n_pData[m_pLink[indcx]==x)；//是否找到
}

⑩ 求dijkstra+heap算法pascal模板，谢大神！

program Dijkstra_heap;
type
path=record
des,dis,next:longint;
end;
var
i,j,k,l,m,n,top:longint;
dis:array[1..100000]of int64; //到源点的距离
head,num,heap:array[1..100000]of longint; //num[i]是i在堆中的位置，heap是堆
g:array[1..1000000]of path;
b:array[1..100000]of boolean; //判断元素是否在堆中
procere up(o:longint);
var
tt,dd:longint;
begin
while o>1 do
begin
tt:=o div 2;
if dis[heap[tt]]>dis[heap[o]] then
begin
dd:=heap[tt];heap[tt]:=heap[o];heap[o]:=dd;
num[heap[o]]:=o;num[heap[tt]]:=tt; //更新元素的位置
o:=tt;
end
else break;
end;
end;
procere down(o:longint);
var
tt,dd,gg,a,c:longint;
begin
while o*2<=top do
begin
dd:=o*2;gg:=o*2+1;
a:=o;
if dd<=top then
if dis[heap[dd]]<dis[heap[a]] then a:=dd;
if gg<=top then
if dis[heap[gg]]<dis[heap[a]] then a:=gg;
if a<>o then
begin
c:=heap[a];heap[a]:=heap[o];heap[o]:=c;
num[heap[a]]:=a;num[heap[o]]:=o; //更新元素位置
o:=a;
end
else break;
end;
end;
begin
assign(input,'input.txt');reset(input);
assign(output,'output.txt');rewrite(output);
readln(n,m);
top:=0;
for i:=1 to n do head[i]:=0;
for i:=1 to m do
begin
readln(j,k,l);
inc(top);
g[top].des:=k;g[top].dis:=l;
g[top].next:=head[j];head[j]:=top;
end;
for i:=1 to n do begin dis[i]:=maxlongint;b[i]:=true; end;
dis[1]:=0;
for i:=1 to n do begin heap[i]:=i;num[i]:=i; end;
top:=n;
for i:=1 to n do
begin
k:=heap[1];b[k]:=false; //取出堆顶元素
j:=head[k];
heap[1]:=heap[top];dec(top);down(1);
while j<>0 do
begin
if b[g[j].des] then
if dis[g[j].des]>dis[k]+g[j].dis then
begin
dis[g[j].des]:=dis[k]+g[j].dis; //更新堆中元素
up(num[g[j].des]);
end;
j:=g[j].next;
end;
end;
writeln(dis[n]);
close(input);close(output);
end.