算法模板

⑴ 模板超高工程量 算法

是0.4*0.4*4.2 然后0.4*0.4*（4.2-3.6)另外再算。超高一米，两米，三米...叠加的。不足0.5的不算，大于0.5米不足一米按超高一米计算。

⑵ 请高手帮我把下面的dijkstra算法用C语言补充完整

加分，我给你全部的，正好有你这一部分在里面，前几天正好搞完这个！绝对好用！！！

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

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

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

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

⑷ 函数模板的基本格式是什么

1.函数模板主要用于具有相同的作用的函数，但是数据类型不一致。
函数模板实现了类型无关并且只在需要时自动实例化。

2.template <class T>
其中class关键字表明T是一个类型。

3.格式是一样的，主要改变的是函数名、形式参数的个数、返回值类型与函数体的内容。

⑸ 垫层模板的计算方法是怎样

是按垫层的接触混凝土面的面积计算

⑹ 求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.

⑺ c++中用模板函数写冒泡算法，对int,double,char三种数据类型的数据排序（要排在一起）

template <typename T>
void pop_sort(T *arr, int arr_size) {
for (int i = 0; i < arr_size - 1; ++i) {
for (int j = i + 1; j < arr_size; ++j) {
if(arr[i] > arr[j]) {
T tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
}

⑻ 求算法专利申请书的样本

专利申请指南 http://www.sipo.gov.cn/sipo/zlsq/zlsqxz/t20050728_51620.htm 专利申请的基本知识 http://www.hbipo.gov.cn/zlsq-21.htm 专利缴费指南 http://www.sipo.gov.cn/sipo/zlsq/zlsqxz/t20050728_51621.htm 专利申请文件的填写和撰写 http://www.quanso.net/zx/200504/1759z33894.aspx 专利申请文件撰写实例分析 http://www.t999.cn/slfx.htm 专利申请文件示例 http://garden.2118.com.cn/dop/tyyq.html

⑼ 舍伍德算法的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.