多项式算法

㈠ 多项式的计算

求的这个多项式，用M表示
则有2(x²-6x-2) - M=3(4x²-7x-5)
M= 2(x²-6x-2)-3(4x²-7x-5)
=(2x²-12x-4)-(12x²-21x-15)
=2x²-11x-4-12x²+21x+15
=-10x²+9x+11

㈡ CRC 16 校验，如何计算多项式

方法如下：
CRC-16码由两个字节构成，在开始时CRC寄存器的每一位都预置为1，然后把CRC寄存器与8-bit的数据进行异或(异或：二进制运算 相同为0，不同为1；0^0=0;0^1=1;1^0=1;1^1=0)， 之后对CRC寄存器从高到低进行移位，在最高位（MSB）的位置补零，而最低位（LSB，移位后已经被移出CRC寄存器）如果为1，则把寄存器与预定义的多项式码进行异或，否则如果LSB为零，则无需进行异或。重复上述的由高至低的移位8次，第一个8-bit数据处理完毕，用此时CRC寄存器的值与下一个8-bit数据异或并进行如前一个数据似的8次移位。所有的字符处理完成后CRC寄存器内的值即为最终的CRC值。
1．设置CRC寄存器，并给其赋值FFFF(hex)。
2．将数据的第一个8-bit字符与16位CRC寄存器的低8位进行异或，并把结果存入CRC寄存器。 3．CRC寄存器向右移一位，MSB补零，移出并检查LSB。
4．如果LSB为0，重复第三步；若LSB为1，CRC寄存器与多项式码相异或。
5．重复第3与第4步直到8次移位全部完成。此时一个8-bit数据处理完毕。
6．重复第2至第5步直到所有数据全部处理完成。
7．最终CRC寄存器的内容即为CRC值。
CRC(16位)多项式为 X16+X15+X2+1，其对应校验二进制位列为1 1000 0000 0000 0101。

㈢ 多项式计算

如图所示，正常加减就可以，最后合并同类项，a的系数为零，就求出m了

望采纳

㈣ 数据结构一元多项式计算(急求)

struct
poly
{
int
coef;//多项式系数
int
exp;//多项式指数
struct
poly
*next;//指到下一项的指针
}
struct
poly
*add_poly(struct
poly
*pa
,struct
poly
*pb)
{
int
x;//用于存放相同次数项的系数和
struct
poly
*p,*q,*r;
p=pa->next;q=pb->next;
r=pa;pc=pa;
while((p!=NULL)&&(q!=NULL))
{
if(p->exp==q->exp)//如果指数相等,即相同次数,系数则相加
{x=p->coef+q->coef;
if(x!=0)
//如果系数的和不为零则存放到和多项式中
{p->coef=x;r->next=p;r=p;}
p++;q++;//移动到下一项
}//if
else
if(p->exp>q->exp)//如果次数不等,则直接把次数小的系数存放到和多项式中
{r->next=p;r=p;p++;}
else{r->next=q;r=q;q++;}
}//while
end
if(p==NULL)r->next=q;//如果一个多项式已经插完到和多项式中,则把未插完多项式的剩余项直接插入到和多项式中
else
r->next=p;
retrn(pc);
}//add_poly
end

㈤ 一个多项式的算法复杂度 请问下面这个多项式的算法复杂度怎么算

一步一步放宽限制，忽略低阶项。
问题中的忽略低阶项考虑到了当n=1时也成立，所以使用了这种化简方式，严谨。
一般讨论算法复杂度，都是假设n足够大，直接忽略低阶项和高阶项的常数系数，如下：
当n足够大时，sqrt(5n*(3n*(n+2)+4)+6)<sqrt(n*n*n)=n^1.5。

㈥ 多项式计算

#include <stdio.h>
#include<malloc.h>
typedef struct
{
float coef;//系数
int expn;//指数
}
ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}
LNode,*LinkList;
LinkList InitList()//创建链表
{
LinkList L;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
return(L);
}
void Creat(LinkList L,ElemType x)//创建多项式
{
LinkList s,p;
s=(LinkList)malloc(sizeof(LNode));
s->data=x;
p=L;
while(p->next)
p=p->next;
s->next=NULL;
p->next=s;
}
void Insert(LinkList L,LNode p)//插入链表
{
LinkList q,pc;
pc=(LinkList)malloc(sizeof(LNode));
*pc=p;
q=L;
while(q->next)
q=q->next;
pc->next=q->next;
q->next=pc;
}
void AddPolyn(LinkList pa,LinkList pb,LinkList pc)//多项式求和
{
LinkList qa,qb;
LNode qc;
float sum;
int a,b;
qa=pa->next;
qb=pb->next;
while(qa&&qb)
{
a=qa->data.expn;
b=qb->data.expn;;
if(a<b)
{
Insert(pc,*qa);
qa=qa->next;
}
if(a==b)
{
sum=qa->data.coef+qb->data.coef;
if(sum!=0)
{
qc=*qa;
qc.data.coef=sum;
Insert(pc,qc);
qa=qa->next;
qb=qb->next;
}
else
{
qa=qa->next;
qb=qb->next;
}
}
if(a>b)
{
Insert(pc,*qb);
qb=qb->next;
}
while(qa)
{
Insert(pc,*qa);
qa=qa->next;
}
while(qb)
{
Insert(pc,*qb);
qb=qb->next;
}
}
}
void Plus(LinkList pa,LinkList pb,LinkList pc)//多项式的差
{
LinkList qb;
qb=pb->next;
while(qb)
{
qb->data.coef=-(qb->data.coef);
qb=qb->next;
}
AddPolyn(pa,pb,pc);
}

void Print(LinkList L)//输出多项式
{
LinkList p;
p=L->next;
while(p->next)
{
printf("%fx^%d+",p->data.coef,p->data.expn);
p=p->next;
}
printf("%fx^%d",p->data.coef,p->data.expn);
}
void main()//主函数
{
LinkList La,Lb,Lc,Ld;ElemType c;
int a,i;
La=InitList();
Lb=InitList();
Lc=InitList();
Ld=InitList();
printf("输入La的项数:");
scanf("%d",&a);
for(i=0;i<a;i++)
{
printf("输入La第%d项系数和指数:",i+1);
scanf("%f%d",&c.coef,&c.expn);
Creat(La,c);
}
printf("输入Lb的项数:");
scanf("%d",&a);
for(i=0;i<a;i++)
{
printf("输入Lb第%d项系数和指数:",i+1);
scanf("%f%d",&c.coef,&c.expn);
Creat(Lb,c);
}
printf("La为");
printf("\n");
Print(La);
printf("\n");
printf("Lb为");
printf("\n");
Print(Lb);
printf("\n");
printf("多项式和为");
printf("\n");
AddPolyn(La,Lb,Lc);
Print(Lc);
printf("\n");
printf("多项式差为");
printf("\n");
Plus(La,Lb,Ld);
Print(Ld);
}
给你编好了，你先试试，有问题再问我。

㈦ 多项式 求根的算法和程序

这题可以用二分法步进试探求解。当然这里说的二分法不是像谭浩强书上的那么简单明了,不是一个f(x1)*f(x2)<0就可以确定的。因为他举例子是在一个单调区间求根，而这里是要求出所有解，区间不一定是单调的。上次我发了一个类似的程序有人评价说不好，那不过是他根本没理解非单调区间找出所有根和单调区间找一个根难度根本不可比较，说明他根本没理解算法目的。

这里的思路是先定一个区间[a,b]然后从a开始以步长h在[a,a+h]内搜索是否有根，然后[a+h,a+2*h],直到区间右端到达b为止。a,b如何大概确定？可以利用高等数学中的高阶导数求出多项式何时恒为正或恒为负决定，这个不难。显然a,b的区间越小程序执行越快。所以a,b尽量定准确一些。程序中定得比较大[-100,150],实际改得越精确越好，当然不能漏根。同时h越小计算时间越长，但是结果精度越高，所以取值要以程序要求的精确度和执行时间综合考虑，这里取0.1。

同时为了提高计算速度，使用了着名的霍纳求值法。即求3x^3-5x^2+x+1转化为求((3x-5)x+1)x+1,因为第一种求法要做7次乘法而带括号的求法只用做3次乘法。当然如果多项式函数是奇函数或偶函数还可以简化[a,b]区间。
程序中设定了一个多项式，实际更改为所求多项式即可。
一个完整的c程序如下,程序在win-tc和Dev-c++下都调试通过。
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

double Equation(double x)
{
double z;
z=(((((x-5.0)*x+3.0)*x+1.0)*x-7.0)*x+7.0)*x-20.0;/*更改为实际多项式*/
return(z);
}

int BinSearchRoot(double a,double b,double h,double eps,double x[],int m) /*用二分法计算非线性方程的实根*/
/*参数意义：
a 要求的根的下界
b 要求的根的上界，即：所求的根落在区间 [a,b]之内
h 递进的步长
eps 精度
x 根的值
m 预计的根的个数*/
{
int n,js;
double z,y,z1,y1,z0,y0;
n=0; z=a; y=Equation(z);
while ((z<=b+h/2.0)&&(n!=m)) /*对给定步长的子区间进行搜索*/
{
if (fabs(y)<eps) /*当前的判定点是方程的根*/
{
n=n+1;
x[n-1]=z;
z=z+h/2.0;
y=Equation(z);
}
else /*当前点不是方程的根*/
{
z1=z+h;
y1=Equation(z1);
if (fabs(y1)<eps) /*下一个点是方程的根*/
{
n=n+1;
x[n-1]=z1;
z=z1+h/2.0;
y=Equation(z);
}
else if (y*y1>0.0) /*该区间内无根*/
{ y=y1; z=z1;}
else /*该区间内有根*/
{
js=0;/*标志，0表示未找到根，1表示已经确定了根*/
while (js==0)
{
if (fabs(z1-z)<eps) /*区间的长度小于给定的精度，可以当作已经找到了根*/
{
n=n+1;
x[n-1]=(z1+z)/2.0; /*把区间的中位值作为根*/
z=z1+h/2.0; /*把寻找的位置放到下一个区间内*/
y=Equation(z);
js=1; /*在当前区间内已经找到了根*/
}
else /*区间比给定的精度大，则进行二分*/
{
z0=(z1+z)/2.0; /*区间二分*/
y0=Equation(z0);
if (fabs(y0)<eps) /*z0位置为根*/
{
x[n]=z0;
n=n+1;
js=1;
z=z0+h/2.0;
y=Equation(z);
}
else if ((y*y0)<0.0) /*[z,z0]内有根*/
{ z1=z0; y1=y0;}
else { z=z0; y=y0;}
}
}
}
}
}
return(n); /*返回根的个数*/
}

int main()
{
int i,n;
static int m=6;
static double x[6];
system("cls");
printf("\nThe Nonlinear function is:\n");
printf("\nf(x)=(((((x-5.0)*x+3.0)*x+1.0)*x-7.0)*x+7.0)*x-20.0\n"); /*更改为实际多项式*/
n=BinSearchRoot(-100.0,150.0,0.1,0.000001,x,m);
printf("\nThe function has %d roots, they are:\n",n);/*输出根的个数*/
for (i=0; i<=n-1; i++)
printf("x(%d)=%10.7f\n",i,x[i]);
system("pause");
return 0;
}

后记:网络是个比较浮躁的地方，个别人说三道四，我一笑了之。真正正确的东西他理解不了，只能说明他还没达到那个层次，要从自身找原因。

显然二分法是不能解决虚根问题的。

㈧ 多项式算法

(1)9X+4
(2)X-12
(3）3X平方-8X-13
(4)5X平方-23X+9
(5)3X平方-14X+9
(6)X的3次方+X平方+4+4X
(7)5X+1
(8)5X平方+5X-10
如果你愿意 你把你所有要问的题都弄出来 可恶 那个人比我快1秒!!!!!!!!!!!!!!!!!!!!!!!!

㈨ 数学中多项式的次数怎么计算只要多项式的次数，不要别

由定义决定：一个多项式中次数最高的单项式的次数即为此多项式的次数。

㈩ 什么叫多项式时间算法

定义：若存在一个常数C，使得对于所有n>=0，都有|f(n)|
<=
C*|g(n)|，则称函数f(n)是O(g(n))。时间复杂度是O(p(n))的算法称为多项式时间算法，这里p(n)是关于n的多项式。不能够这样限制时间复杂度的算法被称为指数时间算法。
例如：时间复杂度为O(nlog(n))、O(n^3)的算法都是多项式时间算法，时间复杂度为O(n^log(n))、O(n!)、O(2^n)的算法是指时间算法。
一个优化问题如果已经找到了多项式时间算法，则称该问题为多项式时间可解问题，并将这类问题的集合记为P，因此多项式时间可解问题就称为P类问题。
一个问题如果没有找到多项式时间算法，那么直觉上它是“难解”的，但又往往无法证明多项式时间算法的不存在性。由于在寻找有效算法上的失败未必一定意味着这样的算法不存在，这就给理论工作者带来了一个难题：一方面证明一个问题不存在多项式时间算法是困难的，至今尚未给出；另一方面有越来越多的问题无法给出多项式时间算法。同时，理论工作者又渴望解决此难题。为此，在20世纪70年代提供了一个漂亮的理论，它把这种失败归结为一个深刻的数据猜想，这个理论就是NP-完全性理论。
定义：给定一个判定问题，如果存在一个算法，对任何一个答案为“是”的实例I。该算法首先给出一个猜想，该猜想规模不超过I的输入长度的某个多项式函数，且验证猜想的正确性仅需多项式时间，则称该问题属于NP类。
定义：如果NP类中所有问题都可以多项式时间归约到NP类中某个问题x，则称x是NP-完全问题。
定义：如果某优化问题x的判定问题是NP-完全的，则称问题x是NP-难的；如果x的判定问题是强NP-完全的，则称x是强NP-难的。