多項式演算法

㈠ 多項式的計算

求的這個多項式，用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-難的。