A. 贪心算法的时效性是什么
请问下你说时效性的时间复杂度的意思吗，在能用贪心算法的情况下，贪心的时间复杂度肯定时极低的。
B. 贪心算法
#include <stdio.h>
#define M 100
void main()
{
int i,j,k,temp,m,n;
int t[M]={2,14,4,16,6,5,3},p[M]={1,2,3,4,5,6,7},s[M],d[M]={0};
m=3;n=7;
for(i=0;i<7;i++)
for(j=0;j<7-i;j++)
if(t[j]<t[j+1])
{
temp=t[j];
t[j]=t[j+1];
t[j+1]=temp;
temp=p[j];
p[j]=p[j+1];
p[j+1]=temp;
}
for(i=0;i<m;i++) //求时间。
{
s[i]=p[i];
d[i]=t[i];
}
for(k=0;k<m;k++)
printf(" %d",d[k]);
printf("\n");
for(i=m;i<n;i++)
{
for(k=0;k<m-1;k++) //求最小。
{
temp=d[k];
if(temp>d[k+1])
{temp=d[k+1];j=k+1;}
}
printf("这是最小下标的： %d\n",j);
printf("最小的值： %d\n",temp);
for(k=0;k<m;k++)
printf(" %d",d[k]);
printf("\n");
//j=temp;
s[j]=s[j]+p[i];
d[j]=d[j]+t[i];
}
printf("\n");
for(k=0;k<7;k++)
printf(" %d",t[k]);
printf("\n");
for(k=0;k<7;k++)
printf(" %d",p[k]);
printf("\n");
for(k=0;k<m;k++)
printf(" %d",s[k]);
printf("\n");
for(k=0;k<m;k++)
printf(" %d",d[k]);
printf("\n");
}
C. 贪心法的时间复杂度由哪个操作决定
待处理数据的状态、问题的规模
时间复杂度取决于:待处理数据的状态、问题的规模。算法复杂度分为时间复杂度和空间复杂度。
D. 贪心算法的时间复杂度
贪心算法只是一个解决问题的策略。同样是采用贪心算法的计算方式，解决不同的问题，它们的时间复杂度是不一样的，不能够一概而论的。
E. 贪心算法马的遍历 时间复杂度
【问题描述】
马的遍历问题。在8×8方格的棋盘上，从任意指定方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条路径。
【初步设计】
首先这是一个搜索问题，运用深度优先搜索进行求解。算法如下：
1、 输入初始位置坐标x,y；
2、 步骤 c:
如果c>64输出一个解，返回上一步骤c--
(x,y) ← c
计算(x,y)的八个方位的子结点，选出那此可行的子结点
循环遍历所有可行子结点，步骤c++重复2
显然（2）是一个递归调用的过程，大致如下：
void dfs(int x,int y,int count)
{
int i,tx,ty;
if(count>N*N)
{
output_solution();//输入一个解
return;
}
for(I=0;i<8;++i)
{
tx=hn[i].x;//hn[]保存八个方位子结点
ty=hn[i].y;
s[tx][ty]=count;
dfs(tx,ty,count+1);//递归调用
s[tx][ty]=0;
}
}
这样做是完全可行的，它输入的是全部解，但是马遍历当8×8时解是非常之多的，用天文数字形容也不为过，这样一来求解的过程就非常慢，并且出一个解也非常慢。
怎么才能快速地得到部分解呢？
【贪心算法】
其实马踏棋盘的问题很早就有人提出，且早在1823年，J.C.Warnsdorff就提出了一个有名的算法。在每个结点对其子结点进行选取时，优先选择‘出口’最小的进行搜索，‘出口’的意思是在这些子结点中它们的可行子结点的个数，也就是‘孙子’结点越少的越优先跳，为什么要这样选取，这是一种局部调整最优的做法，如果优先选择出口多的子结点，那出口少的子结点就会越来越多，很可能出现‘死’结点（顾名思义就是没有出口又没有跳过的结点），这样对下面的搜索纯粹是徒劳，这样会浪费很多无用的时间，反过来如果每次都优先选择出口少的结点跳，那出口少的结点就会越来越少，这样跳成功的机会就更大一些。这种算法称为为贪心算法，也叫贪婪算法或启发示算法，它对整个求解过程的局部做最优调整，它只适用于求较优解或者部分解，而不能求最优解。这样的调整方法叫贪心策略，至于什么问题需要什么样的贪心策略是不确定的，具体问题具体分析。实验可以证明马遍历问题在运用到了上面的贪心策略之后求解速率有非常明显的提高，如果只要求出一个解甚至不用回溯就可以完成，因为在这个算法提出的时候世界上还没有计算机，这种方法完全可以用手工求出解来，其效率可想而知。
在前面的算法基础之上，增添一些程序加以实现：
函数1：计算结点出口多少
int ways_out(int x,int y)
{
int i,count=0,tx,ty;
if(x<0||y<0||x>=N||y>=N||s[x][y]>0)
return -1;//-1表示该结点非法或者已经跳过了
for(i=0;i<8;++i)
{
tx=x+dx[i];
ty=y+dy[i];
if(tx<0||ty<0||tx>=N||ty>=N)
continue;
if(s[tx][ty]==0)
++count;
}
return count;
}
函数2：按结点出口进行排序
void sortnode(h_node *hn,int n)//采用简单排序法，因为子结点数最多只有8
{
int i,j,t;
h_node temp;
for(i=0;i<n;++i)
{
for(t=i,j=i+1;j<n;++j)
if(hn[j].waysout<hn[t].waysout)
t=j;
if(t>i)
{
temp=hn[i];
hn[i]=hn[t];
hn[t]=temp;
}
}
}
函数3：修改后的搜索函数
void dfs(int x,int y,int count)
{
int i,tx,ty;
h_node hn[8];
if(count>N*N)
{
output_solution();
return;
}
for(i=0;i<8;++i)//求子结点和出口
{
hn[i].x=tx=x+dx[i];
hn[i].y=ty=y+dy[i];
hn[i].waysout=ways_out(tx,ty);
}
sortnode(hn,8);
for(i=0;hn[i].waysout<0;++i);//不考虑无用结点
for(;i<8;++i)
{
tx=hn[i].x;
ty=hn[i].y;
s[tx][ty]=count;
dfs(tx,ty,count+1);
s[tx][ty]=0;
}
}
函数4：主调函数
void main()
{
int i,j,x,y;
for(i=0;i<N;++i)//初始化
for(j=0;j<N;++j)
s[i][j]=0;
printf("Horse jump while N=%d\nInput the position to start:",N);
scanf("%d%d",&x,&y);//输入初始位置
while(x<0||y<0||x>=N||y>=N)
{
printf("Error! x,y should be in 0~%d",N-1);
scanf("%d%d",&x,&y);
}
s[x][y]=1;
dfs(x,y,2);//开始搜索
}
QQ:547758555
有问题的话QQ上说
F. 采用贪心算法进行安排。对算法的时间和空间复杂度进行分析
时间主要是 排序用时了，快速排序 一般是 o(n*logn)
空间 复杂度基本上是 0(1)
G. tsp问题的贪心算法，分析时间复杂度，试分析是否存在o的有效算法
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产
H. TSP问题的遍历算法和贪心算法有什么区别,为什么不选择遍历算法
所有问题遍历算法的时间复杂度是最高的，但是对于TSP问题来说贪心算法一般是得不到最优解的
I. pascal贪心算法是什么啊
贪心算法
1．概念
贪心算法是从问题的某一个初始解出发逐步逼近给定的目标，以
尽可能快地求得更好的解。当达到某算法中的某一步不能再继续
前进时，算法停止。这时就得到了问题的一个解，但不能保证求
得的最后解是最优的。在改进算法中，贪心算法演化为爬山法。
2．特点及使用范围
贪心算法的优点在于时间复杂度极底。贪心算法与其他最优化算
法的区别在于：它具有不可后撤性，可以有后效性，一般情况下
不满足最优化原理。贪心算法的特点就决定了它的适用范围，他
一般不适用于解决可行性问题，仅适用于较容易得到可行解的最
优性问题。这里较容易得到可行解的概念是：当前的策略选择后，
不会或极少使后面出现无解的情况。另外，对于近年来出现的交
互性题目，贪心算法是一个较好的选择。这是因为，在题目中，
一个策略的结果是随题目的进行而逐渐给出的，我们无法预先知
道所选策略的结果，这与贪心算法不考虑策略的结果和其具有后
效性的特点是不谋而合的。当然，贪心算法还可以为搜索算法提
供较优的初始界值。
J. pascal 贪心算法
贪心算法实质上就是每一步都取最优解。比如背包问题（不是0/1和完全，最原始的那种）可以用贪心快速解决。很显然，它有目光短浅的问题，很多题目还是要用动态规划的
贪心算法
1．概念
贪心算法是从问题的某一个初始解出发逐步逼近给定的目标，以
尽可能快地求得更好的解。当达到某算法中的某一步不能再继续
前进时，算法停止。这时就得到了问题的一个解，但不能保证求
得的最后解是最优的。在改进算法中，贪心算法演化为爬山法。
2．特点及使用范围
贪心算法的优点在于时间复杂度极底。贪心算法与其他最优化算
法的区别在于：它具有不可后撤性，可以有后效性，一般情况下
不满足最优化原理。贪心算法的特点就决定了它的适用范围，他
一般不适用于解决可行性问题，仅适用于较容易得到可行解的最
优性问题。这里较容易得到可行解的概念是：当前的策略选择后，
不会或极少使后面出现无解的情况。另外，对于近年来出现的交
互性题目，贪心算法是一个较好的选择。这是因为，在题目中，
一个策略的结果是随题目的进行而逐渐给出的，我们无法预先知
道所选策略的结果，这与贪心算法不考虑策略的结果和其具有后
效性的特点是不谋而合的。当然，贪心算法还可以为搜索算法提
供较优的初始界值。
具体的算法介绍或教学就要在书上学了