考点：等腰三角形的性质；反比例函数图象上点的坐标特征．
分析：（1）①根据等边对等角可得∠A=∠BCA，∠CBD=∠BDC，∠ECD=∠CED，再根据三角形的一个外角等于与它不相邻的两个内角的和可得∠A+∠BCA=∠CBD，∠A+∠CDB=∠ECD，∠A+∠CED=∠EDM，然后用∠A表示出∠EDM，计算即可求解；
②先根据反比例函数图象上的点的坐标特征表示出点B的坐标，再表示出点C的坐标，然后根据AC∥x轴可得点C、D的纵坐标相同，从而表示出点D的坐标，再代入反比例函数解析式进行计算即可得解．
（2）从数学思想上考虑解答．
解答：解：（1）①∵AB=BC=CD=DE，
∴∠A=∠BCA，∠CBD=∠BDC，∠ECD=∠CED，
根据三角形的外角性质，∠A+∠BCA=∠CBD，∠A+∠CDB=∠ECD，∠A+∠CED=∠EDM，
又∵∠EDM=84°，
∴∠A+3∠A=84°，
解得，∠A=21°；
②∵点B在反比例函数y=图象上，点B，C的横坐标都是3，
∴点B（3，），
∴点C（3，+2），
∵AC∥x轴，点D在AC上，且横坐标为1，
∴A（1，+2），
∵点A也在反比例函数图象上，
解得，k=3；
（2）用已知的量通过关系去表达未知的量，使用转换的思维和方法．（开放题）
点评：本题考查了等腰三角形两底角相等的性质，三角形的一个外角等于与它不相邻的两个内角的和的性质，以及反比例函数图象上点的坐标特征，是基础题．　
其他类似试题
Copyright ? 2011- Inc. All Rights Reserved. 17教育网站 版权所有 备案号：
站长：朱建新9661人阅读
&&&& 1、问题描述：
&&&& 给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为C。问:应如何选择装入背包的物品，使得装入背包中物品的总价值最大?
&&&& 形式化描述：给定c &0, wi &0, vi &0 , 1≤i≤n.要求找一n元向量(x1,x2,…,xn,), xi∈{0,1}, ? ∑ wi xi≤c,且∑ vi xi达最大.即一个特殊的整数规划问题。
&&&&&& 2、最优性原理：
&&&& 设(y1,y2,…,yn)是 (3.4.1)的一个最优解.则(y2,…,yn)是下面相应子问题的一个最优解:
&&&& 证明:使用反证法。若不然,设(z2,z3,…,zn)是上述子问题的一个最优解,而(y2,y3,…,yn)不是它的最优解。显然有
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& ∑vizi & ∑viyi&& (i=2,…,n)
&&&& 且&&&&&&&&&&&&&&&&&&&&&&&&&& w1y1+ ∑wizi&= c
&&&& 因此&&&&&&&&&&&&&&&&&&&&&& v1y1+ ∑vizi (i=2,…,n) & ∑ viyi,
(i=1,…,n)
&&&& 说明(y1,z2, z3,…,zn)是(3.4.1)0-1背包问题的一个更优解,导出(y1,y2,…,yn)不是背包问题的最优解,矛盾。
&&&&&& 3、递推关系：
&&&&设所给0-1背包问题的子问题
&&&& 的最优值为m(i，j)，即m(i，j)是背包容量为j，可选择物品为i，i+1，…，n时0-1背包问题的最优值。由0-1背包问题的最优子结构性质，可以建立计算m(i，j)的递归式:
&&&& 注:(3.4.3)式此时背包容量为j，可选择物品为i。此时在对xi作出决策之后,问题处于两种状态之一:
&&& (1)背包剩余容量是j,没产生任何效益；
&&& (2)剩余容量j-wi,效益值增长了vi ；
&&&& 算法具体代码如下：
//3d10-1 动态规划 背包问题
#include &stdafx.h&
#include &iostream&
const int N = 4;
void Knapsack(int v[],int w[],int c,int n,int m[][10]);
void Traceback(int m[][10],int w[],int c,int n,int x[]);
int main()
int v[]={0,2,1,4,3},w[]={0,1,4,2,3};//下标从1开始
int x[N+1];
int m[10][10];
cout&&&待装物品重量分别为：&&&
for(int i=1; i&=N; i++)
cout&&w[i]&&& &;
cout&&&待装物品价值分别为：&&&
for(int i=1; i&=N; i++)
cout&&v[i]&&& &;
Knapsack(v,w,c,N,m);
cout&&&背包能装的最大价值为：&&&m[1][c]&&
Traceback(m,w,c,N,x);
cout&&&背包装下的物品编号为：&&&
for(int i=1; i&=N; i++)
if(x[i]==1)
cout&&i&&& &;
void Knapsack(int v[],int w[],int c,int n,int m[][10])
int jMax = min(w[n]-1,c);//背包剩余容量上限 范围[0~w[n]-1]
for(int j=0; j&=jMj++)
m[n][j]=0;
for(int j=w[n]; j&=c; j++)//限制范围[w[n]~c]
m[n][j] = v[n];
for(int i=n-1; i&1; i--)
jMax = min(w[i]-1,c);
for(int j=0; j&=jM j++)//背包不同剩余容量j&=jMax&c
m[i][j] = m[i+1][j];//没产生任何效益
for(int j=w[i]; j&=c; j++) //背包不同剩余容量j-wi &c
m[i][j] = max(m[i+1][j],m[i+1][j-w[i]]+v[i]);//效益值增长vi
m[1][c] = m[2][c];
if(c&=w[1])
m[1][c] = max(m[1][c],m[2][c-w[1]]+v[1]);
//x[]数组存储对应物品0-1向量,0不装入背包，1表示装入背包
void Traceback(int m[][10],int w[],int c,int n,int x[])
for(int i=1; i&n; i++)
if(m[i][c] == m[i+1][c])
x[n]=(m[n][c])?1:0;
&&&& 算法执行过程对m[][]填表及Traceback回溯过程如图所示：
&&&&& 从m(i，j)的递归式容易看出，算法Knapsack需要O(nc)计算时间; Traceback需O(n)计算时间；算法总体需要O(nc)计算时间。当背包容量c很大时，算法需要的计算时间较多。例如，当c&2^n时，算法需要Ω(n2^n)计算时间。
&&&&&&&& 4、算法的改进：
&&&& 由m(i,j)的递归式容易证明，在一般情况下，对每一个确定的i(1≤i≤n)，函数m(i,j)是关于变量j的阶梯状单调不减函数。跳跃点是这一类函数的描述特征。在一般情况下，函数m(i,j)由其全部跳跃点唯一确定。如图所示。
&&&& 对每一个确定的i(1≤i≤n)，用一个表p[i]存储函数m(i，j)的全部跳跃点。表p[i]可依计算m(i，j)的递归式递归地由表p[i+1]计算，初始时p[n+1]={(0，0)}。&
&&&& 一个例子：n=3，c=6，w={4，3，2}，v={5，2，1}。
&&&& 函数m(i,j)是由函数m(i+1,j)与函数m(i+1,j-wi)+vi作max运算得到的。因此，函数m(i,j)的全部跳跃点包含于函数m(i+1，j)的跳跃点集p[i+1]与函数m(i+1，j-wi)+vi的跳跃点集q[i+1]的并集中。易知，(s,t)∈q[i+1]当且仅当wi&=s&=c且(s-wi,t-vi)∈p[i+1]。因此，容易由p[i+1]确定跳跃点集q[i+1]如下：
q[i+1]=p[i+1]⊕(wi,vi)={(j+wi,m(i,j)+vi)|(j,m(i,j))∈p[i+1]}
&&&&另一方面，设(a，b)和(c，d)是p[i+1]∪q[i+1]中的2个跳跃点，则当c&=a且d&b时，(c，d)受控于(a，b)，从而(c，d)不是p[i]中的跳跃点。除受控跳跃点外，p[i+1]∪q[i+1]中的其他跳跃点均为p[i]中的跳跃点。
&&&&由此可见，在递归地由表p[i+1]计算表p[i]时，可先由p[i+1]计算出q[i+1]，然后合并表p[i+1]和表q[i+1]，并清除其中的受控跳跃点得到表p[i]。
&&&&& 例：n=5，c=10，w={2，2，6，5，4}，v={6，3，5，4，6}。跳跃点的计算过程如下：
&&& 初始时p[6]={(0,0)}，(w5,v5)=(4,6)。因此，q[6]=p[6]⊕(w5,v5)={(4,6)}。 p[5]={(0,0),(4,6)}。q[5]=p[5]⊕(w4,v4)={(5,4),(9,10)}。从跳跃点集p[5]与q[5]的并集p[5]∪q[5]={(0,0),(4,6),(5,4),(9,10)}中看到跳跃点(5,4)受控于跳跃点(4,6)。将受控跳跃点(5,4)清除后，得到
&&&& p[4]={(0,0),(4,6),(9,10)}
&&&& q[4]=p[4]⊕(6，5)={(6，5)，(10，11)}
&&&& p[3]={(0，0)，(4，6)，(9，10)，(10，11)}
&&&& q[3]=p[3]⊕(2，3)={(2，3)，(6，9)}
&&&& p[2]={(0，0)，(2，3)，(4，6)，(6，9)，(9，10)，(10，11)}
&&&& q[2]=p[2]⊕(2，6)={(2，6)，(4，9)，(6，12)，(8，15)}
&&&& p[1]={(0，0)，(2，6)，(4，9)，(6，12)，(8，15)}
&&&& p[1]的最后的那个跳跃点(8,15)给出所求的最优值为m(1,c)=15。
&&& 具体代码实现如下：
//3d10-2 动态规划 背包问题 跳跃点优化
#include &stdafx.h&
#include &iostream&
const int N = 4;
template&class Type&
int Knapsack(int n,Type c,Type v[],Type w[],int **p,int x[]);
template&class Type&
void Traceback(int n,Type w[],Type v[],Type **p,int *head,int x[]);
int main()
int v[]={0,2,1,4,3},w[]={0,1,4,2,3};//下标从1开始
int x[N+1];
int **p = new int *[50];
for(int i=0;i&50;i++)
p[i] = new int[2];
cout&&&待装物品重量分别为：&&&
for(int i=1; i&=N; i++)
cout&&w[i]&&& &;
cout&&&待装物品价值分别为：&&&
for(int i=1; i&=N; i++)
cout&&v[i]&&& &;
cout&&&背包能装的最大价值为：&&&Knapsack(N,c,v,w,p,x)&&
cout&&&背包装下的物品编号为：&&&
for(int i=1; i&=N; i++)
if(x[i]==1)
cout&&i&&& &;
for(int i=0;i&50;i++)
delete p[i];
template&class Type&
int Knapsack(int n,Type c,Type v[],Type w[],int **p,int x[])
int *head = new int[n+2];
head[n+1]=0;
p[0][0]=0;//p[][0]存储物品重量
p[0][1]=0;//p[][1]存储物品价值，物品n的跳跃点（0，0）
// left 指向p[i+1]的第一个跳跃点，right指向最后一个
//拿书上的例子来说，若计算p[3]=0;则left指向p[4]的第一跳跃点（0 0）right指向（9,10）
int left = 0,right = 0,next = 1;//next即下一个跳跃点要存放的位置
head[n]=1;//head[n]用来指向第n个物品第一个跳跃点的位置
for(int i=n; i&=1; i--)
int k =//k指向p[ ]中跳跃点,移动k来判断p[]与p[]+（w v）中的受控点
for(int j= j&= j++)
if(p[j][0]+w[i]&c)//剩余的空间不能再装入i，退出for循环;
Type y = p[j][0] + w[i],m = p[j][1] + v[i];//计算p[ ]+（w v）
//若p[k][0]较小则(p[k][0]
p[k][1])一定不是受控点，将其作为p[i]的跳跃点存储
while(k&=right && p[k][0]&y)
p[next][0]=p[k][0];
p[next++][1]=p[k++][1];
//如果 p[k][0]==y而m&p[k][1]，则（y m）为受控点不存
if(k&=right && p[k][0]==y)
if(m&p[k][1])//对（p[k][0]
p[k][1]）进行判断
m=p[k][1];
// 若p[k][0]&=y且m& =p[k][1],判断是不是当前i的最后一个跳跃点的受控点
//若不是则为i的跳跃点存储
if(m&p[next-1][1])
p[next][0]=y;
p[next++][1]=m;
//若是，则对下一个元素进行判断。
while(k&=right && p[k][1]&=p[next-1][1])
while(k&=right)
p[next][0]=p[k][0];
p[next++][1]=p[k++][1];//将i+1剩下的跳跃点作为做为i的跳跃点存储
left = right + 1;
right = next - 1;
// 第i-1个物品第一个跳跃点的位置
head[0]指第0个物品第一个跳跃点的位置
head[i-1] =
Traceback(n,w,v,p,head,x);
return p[next-1][1];
//x[]数组存储对应物品0-1向量,0不装入背包，1表示装入背包
template&class Type&
void Traceback(int n,Type w[],Type v[],Type **p,int *head,int x[])
//初始化j,m为最后一个跳跃点对应的第0列及第1列
//如上例求出的 最后一个跳跃点为（8 15）j=8,m=15
Type j = p[head[0]-1][0],m=p[head[0]-1][1];
for(int i=1; i&=n; i++)
x[i]=0;// 初始化数组；
for(int k=head[i+1]; k&=head[i]-1;k++)// 初始k指向p[2]的第一个跳跃点（0 0）
//判断物品i是否装入，如上例与跳跃点(6 9)相加等于（8 15）所以1装入
if(p[k][0]+w[i]==j && p[k][1]+v[i]==m)
x[i]=1;//物品i被装入，则x[i]置1
j=p[k][0];// j和m值置为满足if条件的跳跃点对应的值
m=p[k][1];// 如上例j=6,m=9
//再接着判断下一个物品
&&&& 上述算法的主要计算量在于计算跳跃点集p[i](1≤i≤n)。由于q[i+1]=p[i+1]⊕(wi，vi)，故计算q[i+1]需要O(|p[i+1]|)计算时间。合并p[i+1]和q[i+1]并清除受控跳跃点也需要O(|p[i+1]|)计算时间。从跳跃点集p[i]的定义可以看出，p[i]中的跳跃点相应于xi,…,xn的0/1赋值。因此，p[i]中跳跃点个数不超过2^(n-i+1)。由此可见，算法计算跳跃点集p[i]所花费的计算时间为从而，改进后算法的计算时间复杂性为O(2^n)。当所给物品的重量wi(1≤i≤n)是整数时，|p[i]|≤c+1，(1≤i≤n)。在这种情况下，改进后算法的计算时间复杂性为O(min{nc,2^n})。
&&&&运行结果如图：
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：204096次
积分：2914
积分：2914
排名：第4489名
原创：57篇
转载：33篇
评论：120条
文章：50篇
阅读：157831
(1)(1)(3)(1)(1)(3)(1)(4)(5)(11)(4)(14)(13)(1)(3)(1)(3)(3)(2)(1)(13)(1)教师讲解错误
错误详细描述：
有这样一道题目：“已知二次函数y＝ax2＋bx＋c的图象经过点A（0，a），B（1，－2），，且这个二次函数图象的对称轴为直线x＝2”，题目中的矩形部分是一段被墨水污染了无法辨认的文字．（1）根据现有的信息，你能否求出题目中二次函数的表达式？若能，写出求解过程；若不能，说明理由；（2）请你根据已有信息，在原题中的矩形框内，填一个适当的条件，把原题补充完整．
【解析过程】
开放题的特点，答案不唯一，解决此类问题，应捕捉题设中的各种信息，并借助学过的有关二次函数图象的知识．
解：（1）∵二次函数y＝ax2＋bx＋c的图象经过点A（0，a），B（1，－2），∴a＝c，－2＝a＋b＋c，又∵抛物线y＝ax2＋bx＋c的对称轴为直线x＝2，∴，故可组成方程组解得∴能求出二次函数的表达式，表达式为y＝x2－4x＋1．（2）可补充的条件有（任选其一即可）：①满足函数表达式的任一点的坐标，如“图象过点（3，－2）”；②a＝1或b＝－4或c＝1；③抛物线与y轴的交点坐标为（0，1）；④抛物线与x轴的交点坐标为（，0）或（，0）；⑤函数的最小值为－3；⑥抛物线的顶点坐标为（2，－3）；⑦b2－4ac＝12．
电话：010-
地址：北京市西城区新街口外大街28号B座6层601
微信公众号
COPYRIGHT (C)
INC. ALL RIGHTS RESERVED. 题谷教育 版权所有
京ICP备号 京公网安备3162人阅读
算法设计与分析--求最大子段和问题
问题描述：
给定由n个整数组成的序列(a1,a2, …,an)，求该序列形如
&的子段和的最大值，当所有整数均为负整数时，其最大子段和为0。
利用蛮力法求解：
int maxSum(int a[],int n)
int maxSum = 0;
int sum = 0;
for(int i = 0; i & i++) //从第一个数开始算起
for(int j = i + 1; j & j++)//从i的第二个数开始算起
sum = a[i];
if(a[i] & sum)
sum = a[i];
//每一趟的最大值
if(sum & maxSum)
return maxS
利用分治法求解：
int maxSum(int a[],int left, int right)
int sum = 0;
if(left == right) //如果序列长度为1，直接求解
if(a[left] & 0) sum = a[left];
else sum = 0;
int center = (left + right) / 2; //划分
int leftsum = maxSum(a,left,center); //对应情况1，递归求解
int rightsum = maxSum(a, center + 1, right);//对应情况2， 递归求解
int s1 = 0;
int lefts = 0;
for(int i = i &= i--) //求解s1
lefts += a[i];
if(lefts & s1) s1 = //左边最大值放在s1
int s2 = 0;
int rights = 0;
for(int j = center + 1; j &= j++)//求解s2
rights += a[j];
if(rights & s2) s2 =
sum = s1 + s2;
//计算第3钟情况的最大子段和
if(sum & leftsum) sum = //合并，在sum、leftsum、rightsum中取最大值
if(sum & rightsum) sum =
利用动态规划法求解：
int DY_Sum(int a[],int n)
int sum = 0;
int *b = (int *) malloc(n * sizeof(int)); //动态为数组分配空间
b[0] = a[0];
for(int i = 1; i & i++)
if(b[i-1] & 0)
b[i] = b[i - 1] + a[i];
b[i] = a[i];
for(int j = 0; j & j++)
if(b[j] & sum)
sum = b[j];
delete []b;
//释放内存
完整测试程序：
#include&iostream&
#include&time.h&
#include&Windows.h&
#define MAX 10000
int BF_Sum(int a[],int n)
int max=0;
int sum=0;
for (i=0;i&n-1;i++)
for(j=i+1;j&n;j++)
if(sum&=max)
sum+=a[j];
int maxSum1(int a[],int left, int right)
int sum = 0;
if(left == right) //如果序列长度为1，直接求解
if(a[left] & 0) sum = a[left];
else sum = 0;
int center = (left + right) / 2; //划分
int leftsum = maxSum1(a,left,center); //对应情况1，递归求解
int rightsum = maxSum1(a, center + 1, right);//对应情况2， 递归求解
int s1 = 0;
int lefts = 0;
for(int i = i &= i--) //求解s1
lefts += a[i];
if(lefts & s1) s1 = //左边最大值放在s1
int s2 = 0;
int rights = 0;
for(int j = center + 1; j &= j++)//求解s2
rights += a[j];
if(rights & s2) s2 =
sum = s1 + s2;
//计算第3钟情况的最大子段和
if(sum & leftsum) sum = //合并，在sum、leftsum、rightsum中取最大值
if(sum & rightsum) sum =
int DY_Sum(int a[],int n)
int sum = 0;
int *b = (int *) malloc(n * sizeof(int)); //动态为数组分配空间
b[0] = a[0];
for(int i = 1; i & i++)
if(b[i-1] & 0)
b[i] = b[i - 1] + a[i];
b[i] = a[i];
for(int j = 0; j & j++)
if(b[j] & sum)
sum = b[j];
delete []b;
//释放内存
int main()
int num[MAX];
const int n = 40;
LARGE_INTEGER begin,end,
QueryPerformanceFrequency(&frequency);
//生成随机序列
cout&&&生成随机序列：&;
srand(time(0));
for(int i = 0; i & i++)
if(rand() % 2 == 0)
num[i] = rand();
num[i] = (-1) * rand();
if(n & 100)
cout&&num[i]&&& &;
//蛮力法//
cout&&&\n蛮力法:&&&
cout&&最大字段和：&;
QueryPerformanceCounter(&begin);
cout&&BF_Sum(num,n)&&
QueryPerformanceCounter(&end);
cout&&&时间:&
&&(double)(end.QuadPart - begin.QuadPart) / frequency.QuadPart
cout&&&\n分治法:&&&
cout&&最大字段和：&;
QueryPerformanceCounter(&begin);
cout&&maxSum1(num,0,n)&&
QueryPerformanceCounter(&end);
cout&&&时间:&
&&(double)(end.QuadPart - begin.QuadPart) / frequency.QuadPart
cout&&&\n动态规划法:&&&
cout&&最大字段和：&;
QueryPerformanceCounter(&begin);
cout&&DY_Sum(num,n)&&
QueryPerformanceCounter(&end);
cout&&&时间:&
&&(double)(end.QuadPart - begin.QuadPart) / frequency.QuadPart
system(&pause&);
测试结果：
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1051940次
积分：16809
积分：16809
排名：第179名
原创：550篇
转载：81篇
评论：1307条
阅读：27361
阅读：17040
文章：12篇
阅读：27166
文章：11篇
阅读：42535
文章：10篇
阅读：30420
文章：13篇
阅读：13907
文章：13篇
阅读：121424
(4)(5)(6)(7)(2)(13)(11)(11)(8)(14)(10)(16)(8)(15)(23)(13)(12)(12)(11)(17)(28)(18)(20)(8)(11)(20)(13)(14)(10)(23)(18)(15)(36)(27)(47)(16)(3)(28)(33)(14)(13)
从入门到成长到成熟再到优秀，大多数程序员走了前面一段相似的道路，而有些人却走得更远一些！！！！对于大规模复杂问题求解,是否硬件系统的cpu数目越多求解效率越高?为什么?_百度知道
对于大规模复杂问题求解,是否硬件系统的cpu数目越多求解效率越高?为什么?
请从数据结构与算法方面回答
提问者采纳
不一定，CPU数目也是一方面，CPU的线程、硬盘的性能、主板芯片的能力，显卡的档次都能影响到效率，电脑效率是一个综合指标,算法简单说有这几个：1，先来先服务（Frist Come First Servies简写FCFS)算法FCFS算法是一种最简单的调度算法，不支持进程的抢先操作。仅仅是按照进程到达就绪队列的顺序，先进入就绪队列的先执行。实现FCFS调度算法非常简单，仅仅需要编写一个队列的数据结构处理即可。2，短任务优先（Shortest Job First简写SJF)算法SJF算法是理论上最好的调度算法，是平均等待时间最少的算法。同样是非抢先的操作。对于SJF算法实现上面需要对于就绪队列中进程CPU时间片为关键码执行排序。这里可以使用任何一种排序算法，不过考虑效率和动态添加来看这里最佳的排序算法应该是考虑堆排序，不仅开销上面可以控制在nlogn级别上，而且还可以动态的将新的就绪进程添加到CPU等待队列中。虽然SJF算法是最好的算法，但是由于需要依赖进程到达和CPU时间片做依赖，所以SJF算法一般不直接作为主要的调度算法，而是和其他算法搭配使用。3，轮转（Round-Robin简写RR)算法RR算法是一种抢先的调度算法，是专门为分时操作系统设计的。通过一个单元时间片不断的循环处理就绪队列的进程。对于RR算法实现的数据结构类似于FCFS算法，通过队列实现。需要注意的是对于在时间片内处理完成的进程直接队头删除，对于没有完成的需要在执行时间减去时间片后再次加入队列尾部。对于真个算法的性能关键是单元时间片的设置，如果单元时间片超过最大等待进程的进程CPU时间片，该算法将等同于FCFS算法的效率。4，优先级调度(Priority Scheduling简写PS)算法优先级调度可以是抢先或者是非抢先的调度。优先级算法会更具就绪进程队列的优先级作为关键玛进行排序，然后再和上面FCFS、SJF或者RR算法组合使用。对于实现上面主要需要一个排序算法来处理优先级的排序。
其他类似问题
按默认排序
其他1条回答
不一定，CPU快一点虽然好，但是其他硬件要和CPU配合，其他硬件也要保持足够的指标
硬件系统的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁