代价如何算法

Ⅰ 什么是传播代价

传播代价就是说通过相应的传播的成本比如说机器人的长距离传播代价就是通信成本还有就是物质成本

Ⅱ 代价一致搜索是dijkstra吗

你好，本质上代价一致算法是dijkstra算法的一种特殊情况。他们的区别可以从下面几个方面体会。

代价一致算法要解决的问题：寻找从根结点到目标节点之间代价最小的路径，这里面目标节点是确定的。一旦找到目标节点的最小代价路径，算法就停止了。
dijkstra算法要解决的问题：寻找从根节点到图中所有节点的代价最小距离，这里没有给出具体的目标节点，可以认为除了根节点之外其他所有节点都是目标节点。只有当所有节点都被讨论之后，算法才停止。因此对于同样的图，dijkstra用的时间和内存比代价一致算法多。
在数学领域，dijkstra算法出现的较多，因为数学问题往往具有普遍性。而在人工智能领域代价一致算法出现的较多，因为对于一个具体的问题其目标往往是已知的。

dijkstra通常用图表示，代价一致算法通常用树表示。

我也是初学者，上面这些是看了一些资料自己总结的，希望对你理解这两种算法有帮助。

Ⅲ ospf协议的代价是如何计算的

Cost = 100×106/链路带宽
这里，链路带宽以bps来表示。也就是说，OSPF的Cost 与链路的带宽成反比，带宽越高，Cost越小，表示OSPF到目的地的距离越近。举例来说，FDDI或快速以太网的Cost为1，2M串行链路的Cost为48，10M以太网的Cost为10等。

这个是搜来的，和我看过的CCNA上说的基本一致。。详细的你可以看一下地下的链接。

Ⅳ Kruskal算法和Prim算法构造它的一棵最小代价生成树的过程

Prim算法复杂度：O(n2), 与边无关，适合求边稠密的网的最小生成树。

算法思想：假设N={V,{E}}是连通网，TE是N上最小生成树中边的集合。算法从U={u0},TE ={}开始，重复执行下述操作：在所有u∈U,v∈V-U的边（u，v）∈E中找一条代价最小的边（u0,v0）并入集合TE，同时v0并入U，直至U=V为止。

Kruskal算法复杂度：O(eloge)，相对于Prim而言，适合求边稀疏的网的最小生成树。

算法思想：最小生成树的初始状态为只有n个顶点而无边的非连通图T=(V,{})，图中每个顶点自成一个连通分量。在E中选择代价最小的边，若该边依附的顶点落在T中不同的连通分量上，则将此边加入到T中，否则舍去次边而选择下一条代价最小的边。直至T中所有顶点都在同一连通分量上为止。

Ⅳ 如何用Dijkstra算法，求出多条代价相同的路径

伟猪 [转贴 2005-12-15 20:21:00 ] 发表者: 伟伟猪

/***********************************************
设G=(V,E)是一个每条边都有非负长度的有向图，有一个特异的顶点s称为缘。
单源最短路径问题，或者称为最短路径问题，是要确定从s到V中没一个其他
顶点的距离，这里从顶点s到x的距离定义为从s到x的最短路径问题。这个问题
可以用Dijkstra算法解决。下面我给我了c++下的源代码！ --by 伟伟猪
************************************************/
#include<iostream.h>
void main()
{
int infinity=100,j,i,n,k,t,**w,*s,*p,*d;
cout<<"input the value of n:";
cin>>n;
cout<<endl;

d=new int[n];
s=new int[n];
p=new int[n];
w=new int*[n];
for(i=0;i<n;i++)
for(i=0;i<n;i++)
for(j=0;j<n;j++)
cin>>w[i][j];

for(s[0]=1,i=1;i<n;i++)
{
s[i]=0;d[i]=w[0][i];
if(d[i]<infinity) p[i]=0;
else p[i]=-1;
}

for(i=1;i<n;i++)
{
t=infinity;k=1;
for(j=1;j<n;j++)
if((!s[j])&&(d[j]<t))
s[k]=1;//point k join the S
for (j=1;j<n;j++)
if((!s[j])&&(d[j]>d[k]+w[k][j]))

}
cout<<"从源点到其它顶点的最短距离依次如下：";
for(i=1;i<n;i++) cout<<d[i]<<" ";

}
/*********
顶点个数用n表示，这里给出的例子n=6
100 1 12 100 100 100
100 100 9 3 100 100
100 100 100 100 5 100
100 100 4 100 13 15
100 100 100 100 100 4
100 100 100 100 100 100
具体例子见 电子工业出版社 《算法设计技巧与分析》148页
************/

Ⅵ 算法的时间代价

随便解释一下 ，解释的不好见谅
一个算法是解决某个问题的，比如n条数据排序问题，那么对于这个问题“n”就是它的问题规模
那么解决这个问题的算法的代价一定是n的函数，记为T(n)
为了比较不同算法之间的优劣，必须有一种方法将计算代价的函数进行变换，所以提出一种
概念叫做“复杂度”（好像是这么个意思,教材上的那个阴文单词背不出了)
记作T(n)=O(f(n)),表示代价T(n)和f(n)一样
比方说一个算法用时T(n)=n天 ，另一个算法用f(n)=100n天，可以证明
n=O(100n),那么就认为两个算法复杂度相同（1天和100天复杂度还相同,....)

搂住的后半句就是具体定义，“存在正常数C和N,当问题规模n>N时,有T(n)<=Cf(n)”意思就是说如果有一个正的常数C，和一个正的常数N，当n>N 不等式T(n)<=Cf(n)恒成立，就“称某算法的时间(或空间)代价T(n)=O(f(n))”

比如一个算法的代价是T(n)=100n ，那么当n>=1时，100n <= 101 n
那么就可以记作
T(n)=100n = O（n） 这里f(n)是f(n)=n，C=101，N=1

Ⅶ 程序的算法代价是什么

时间和空间。

Ⅷ 付出代价最小的死锁解除算法

摘要 付出代价最小的死锁解除算法

Ⅸ 桶排序的代价

桶排序利用函数的映射关系，减少了几乎所有的比较工作。实际上，桶排序的f(k)值的计算，其作用就相当于快排中划分，已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。
对N个关键字进行桶排序的时间复杂度分为两个部分：
(1) 循环计算每个关键字的桶映射函数，这个时间复杂度是O(N)。
(2) 利用先进的比较排序算法对每个桶内的所有数据进行排序，其时间复杂度为 ∑ O(Ni*logNi) 。其中Ni 为第i个桶的数据量。
很显然，第(2)部分是桶排序性能好坏的决定因素。尽量减少桶内数据的数量是提高效率的唯一办法(因为基于比较排序的最好平均时间复杂度只能达到O(N*logN)了)。因此，我们需要尽量做到下面两点：
(1) 映射函数f(k)能够将N个数据平均的分配到M个桶中，这样每个桶就有[N/M]个数据量。
(2) 尽量的增大桶的数量。极限情况下每个桶只能得到一个数据，这样就完全避开了桶内数据的“比较”排序操作。 当然，做到这一点很不容易，数据量巨大的情况下，f(k)函数会使得桶集合的数量巨大，空间浪费严重。这就是一个时间代价和空间代价的权衡问题了。
对于N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：
O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)
当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。
总结：桶排序的平均时间复杂度为线性的O(N+C)，其中C=N*(logN-logM)。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。当然桶排序的空间复杂度为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。此外，桶排序是稳定的。

Ⅹ 计算以下程序段算法的时间代价

A
外侧跑了n次，内层跑了1次
共n*1，即O(n)