精华内容
下载资源
问答
  • 两个多项式相乘
    千次阅读
    2016-03-31 21:12:00

    一个m项,一个n项

    相加:从第一项开始,每一次都拿两个多项式的头开始比较,小的项就进目标链表,前进一格,从而完成相加,复杂度o(m+n)

     

     

    相乘 :

    算法1:o(m*m*n*n)

       每一项相乘,结果插入目标链表里

    算法2:o(m*n*n)

        拿一个多项式每一项与另一整个多项式相乘,然后将这m个或n个多项式相加;这个算法比上个算法的优点在于利用了这两个多项式升序排的条件

    算法3:待续

    转载于:https://www.cnblogs.com/xuehongyang/p/5342807.html

    更多相关内容
  • 【练习3.7】编写一个函数将两个多项式相乘,用一个链表实现。你必须保证输出的多项式按幂次排列,并且任意幂次最多只有一项。 a.给出以O(M2N2)时间求解该问题的算法。 一种算法是将结果保存在按指数排序的链表中。...

    转载:https://www.cnblogs.com/catnip/p/4331347.html

    【练习3.7】编写一个函数将两个多项式相乘,用一个链表实现。你必须保证输出的多项式按幂次排列,并且任意幂次最多只有一项。

    a.给出以O(M2N2)时间求解该问题的算法。

    一种算法是将结果保存在按指数排序的链表中。每个mn乘法都需要搜索链表中的重复项。由于链接列表的大小为mn,因此总运行时间为O(m 2 n2)。

    b.写一个以O(M2 N)时间执行乘法的程序,其中M≤N。

    M≤1时,方法易知。
    M≥2时,每次将长度为M的链表的一项,与另一链表的所有项相乘,每次一组N个有序的多项式元素。
    对于每两组上式的N个多项式元素,基本按两个有序链表求并的算法(除幂次相同需将系数相加)操作。
    求并算法时间复杂度O(M+N),故该算法复杂度为(乘法时间)O(MN)+(求并时间)O((N+N)+(2N+N)+(3N+N)+……+(MN+N))=O(M2N)

    c.写一个以O(MNlog(MN))时间执行乘法的程序。

    同a先将两链表元素两两相乘并列出,对MN项元素进行O(NlogN)的排序
    排序完成后,遍历代码,合并同幂次项,最后全部插入链表。
    时间复杂度为:(乘法时间)O(MN)+(排序时间)O(MNlogMN)+(合并同类项时间)O(MN)=O(MNlogMN)

    d.上面哪个时间界最好?

    算法的选择取决于m和n的相对值。如果它们接近,那么(c)部分的解决方案更好。如果一个多项式非常小,那么解决方案为:(b)部分更好。

    展开全文
  • Python程序将两个多项式相乘,其中多项式的每个项表示为一对整数(系数,指数)?- >首先要求no。存储每个幂的系数的字典乘以多项式p2的所有系数。然后将所有具有相同功率的字典系数相加。def multpoly(p1,p2):dp1=...

    功能需要两个列表(具有元组作为值)作为输入 我在我的脑海中,后面的算法为此编写代码,但要正确编写它。Python程序将两个多项式相乘,其中多项式的每个项表示为一对整数(系数,指数)?

    - >首先要求no。存储每个幂的系数的字典乘以多项式p2的所有系数。

    然后将所有具有相同功率的字典系数相加。

    def multpoly(p1,p2):

    dp1=dict(map(reversed, p1))

    dp2=dict(map(reversed, p2))

    kdp1=list(dp1.keys())

    kdp2=list(dp2.keys())

    rslt={}

    if len(kdp1)>=len(kdp2):

    kd1=kdp1

    kd2=kdp2

    elif len(kdp1)

    kd1=kdp2

    kd2=kdp1

    for n in kd2:

    for m in kd1:

    rslt[n]={m:0}

    if len(dp1)<=len(dp2):

    rslt[n][m+n]=rslt[n][m+n] + dp1[n]*dp2[m]

    elif len(dp1)>len(dp2):

    rslt[n][m+n]=rslt[n][m+n] + dp2[n]*dp1[m]

    return(rslt)

    +0

    请提出具体问题。 –

    +0

    不清楚你问什么或你的问题是什么 –

    +0

    [this]的可能重复(http://stackoverflow.com/questions/39057546/how-to-calculate-sum-of-two-polynomials/ 39058521#39058521)问题? –

    展开全文
  • //NODE节点的定义,这里最好的就是template模板,AN类型的任何数据域都可以在这里添加,比如再来一结构体定义,data就可以封装多数据 template <class AN> struct NODE { AN DATA; NODE<AN>* next...
    #include<iostream> 
    using namespace std;
    //NODE节点的定义,这里最好的就是template模板,AN类型的任何数据域都可以在这里添加,比如再来一个结构体定义,data就可以封装多个数据
    template <class AN>
    struct NODE
    {
    	AN DATA;
    	NODE<AN>* next = NULL;
    };
    struct element//element就是节点的数据域
    {
    	double a;//系数
    	int e;//指数
    	element(double cc = 0, int ee = 0) :a(cc), e(ee) {};
    };//定义element
    //链表定义基类的定义
    template<class AN>
    class LinkList
    {
    public:
    	LinkList() { front = new NODE<AN>; front->next = NULL; }//无参构造函数
    	LinkList(AN a[], int n);//含参构造函数
    	~LinkList();//析构
    	NODE<AN>* front;
    	int Length = 0;
    };
    //派生类
    class TruList :public LinkList<element>
    {
    public:
    	TruList(element data[], int n) :LinkList(data, n) {};//构造函数,构造出多项式链表
    	void Add(TruList& b);//函数相加
    	void Cut(TruList& b);//函数相减 
    	void Sum(int x);//求某一点的值
    	void Der();//求导数
    	void PrintList();//输出
    	element* OneAndMore(TruList& a, element b);
    	void Pro(TruList& a, TruList& b);//多项式相乘
    };
    //基类构造函数
    template<class AN>
    LinkList<AN>::LinkList(AN a[], int n)//头插法插入数组
    {
    	Length = n;
    	front = new NODE<AN>;
    	front->next = NULL;
    	for (int i = n - 1; i >= 0; i--)
    	{
    		NODE<AN>* s = new NODE<AN>;
    		s->DATA = a[i];
    		s->next = front->next;
    		front->next = s;
    	}
    }
    //基类析构函数
    template<class AN>
    LinkList<AN>::~LinkList()
    {
    	NODE<AN>* p = front;
    	while (p)
    	{
    		front = p;
    		p = front->next;
    		delete front;
    	}
    }
    
    //Add函数
    void TruList::Add(TruList& b)
    {
    	NODE<element>* p_front = front;//p前面的指针
    	NODE<element>* p = p_front->next;//p指针指向a的第一个element
    	NODE<element>* q = b.front->next;//q指向b的第一个element
    	while (p && q)
    	{
    		if (p->DATA.e < q->DATA.e)//a的指数比b小
    		{
    			p_front = p;
    			p = p->next;//p和p_front向后移
    		}
    		else if (p->DATA.e > q->DATA.e)//a的指数比b大,把b加入到a
    		{
    			p_front->next = q;
    			p_front = q;
    			q = q->next;
    			p_front->next = p;
    
    		}
    		else//如果相等
    		{
    			p->DATA.a += q->DATA.a;
    			if (fabs(p->DATA.a) < 1e-7)
    			{
    				p_front->next = p->next;
    				delete p;
    				p = p_front->next;
    			}
    			else
    			{
    				p_front = p;
    				p = p_front->next;
    			}
    			NODE<element>* temp = q;
    			q = q->next;
    			delete temp;
    		}
    	}
    	if (q)p_front->next = q;
    	b.front->next = NULL;
    }
    //CUt函数
    void TruList::Cut(TruList& b)
    {
    	NODE<element>* p_front = front;//p前面的指针
    	NODE<element>* p = p_front->next;//p指针指向a的第一个element
    	NODE<element>* q = b.front->next;//q指向b的第一个element
    	while (p && q)
    	{
    		if (p->DATA.e < q->DATA.e)//a的指数比b小
    		{
    			p_front = p;
    			p = p->next;//p和p_front向后移
    		}
    		else if (p->DATA.e > q->DATA.e)//a的指数比b大,把-b加入到a
    		{
    			q->DATA.a = (-1)*(q->DATA.a);
    			p_front->next = q;
    			p_front = q;
    			q = q->next;
    			p_front->next = p;
    
    		}
    		else
    		{
    			p->DATA.a -= (q->DATA.a);
    			if (fabs(p->DATA.a) < 1e-7)
    			{
    				p_front->next = p->next;
    				delete p;
    				p = p_front->next;
    			}
    			else
    			{
    				p_front = p;
    				p = p_front->next;
    			}
    			NODE<element>* temp = q;
    			q = q->next;
    			delete temp;
    		}
    	}
    	if (q)//q后面还有节点
    	{
    		NODE<element>* qq = q;
    		while (q)
    		{
    			
    			q->DATA.a = (-1) * q->DATA.a;
    			q = q->next;
    		}
    		p_front->next = qq;
    	}
    	b.front->next = NULL;
    }
    //Sum函数
    void TruList::Sum(int x)
    {
    	if (x == 0)throw"0";
    	double sum = 0;
    	NODE<element>* p = front->next;
    	while (p)
    	{
    		if (p->DATA.e < 0)//如果指数为负
    		{
    			int jiecheng = 1;
    			for (int i = 1; i < -(p->DATA.e); i++)
    			{
    				jiecheng = jiecheng * (1 / x) * (1 / x);
    			}
    			sum = sum + (p->DATA.a) * jiecheng;
    		}
    		else if (p->DATA.e == 0)
    		{
    			sum = sum + p->DATA.a;
    		}
    		else
    		{
    			int jiecheng = 1;
    			for (int i = 1; i < (p->DATA.e); i++)
    			{
    				jiecheng = jiecheng * x * x;
    			}
    			sum = sum + (p->DATA.a) * jiecheng;
    		}
    		p = p->next;
    	}
    	cout << sum;
    
    }
    //求导
    void TruList::Der()
    {
    	NODE<element>* p = front->next;
    	NODE<element>* p_front = front;
    	while (p)
    	{
    		if (p->DATA.e != 0)
    		{
    			p->DATA.a = p->DATA.a * p->DATA.e;
    			p->DATA.e = p->DATA.e - 1;
    			if (p->DATA.e != 0)
    			{
    				p_front = p;
    				p = p->next;
    			}
    			else if (p->DATA.e == 0 && p_front->DATA.e == 0)
    			{
    				p_front->DATA.a += p->DATA.a;
    				p = p->next;
    			}
    			else
    			{
    				p_front = p;
    				p = p->next;
    			}
    		}
    		else
    		{
    			p_front = p;
    			p = p->next;
    		}
    
    	}
    }
    //多项式乘单项式
    element* TruList::OneAndMore(TruList& a, element b)//传入多项式链表和单项式的数据域
    {
    
    	NODE<element>* p = a.front->next;//获取第一个
    	element* s = new element[100];//创建element用于存储和返回
    	int i = 0;//i用于s指针的定位
    	while (p)
    	{
    		s[i].a = p->DATA.a * b.a;//s[i]储存相乘的系数和指数
    		s[i].e = p->DATA.e * b.e;
    		i++;//计数+1
    		p = p->next;//多项式后移
    
    	}
        return s;
    }
    //多项式相乘
    void TruList::Pro(TruList& a, TruList& b)//多项式相乘函数,需要传入两个相乘的多项式类
    {
    
    	NODE<element>* p = front->next;//获取第一个多项式
    	NODE<element>* q = b.front->next;//获取第二个多项式
    
    	element kong[1] = {};//创建一个element用于构造储存多项式的对象
    	TruList temp1(kong, 1);//temp1就是用于储存的多项式
    	while (q)//第二个单项式逐项乘第一个多项式
    	{
    		TruList temp2(OneAndMore(a, q->DATA), a.Length);//传入第一个单项式,进行单项式乘多项式
    		temp1.Add(temp2);//多项式相加
    		q = q->next;
    	}
    	temp1.PrintList();//输出
    }
    //输出函数
    void TruList::PrintList()
    {
    	NODE<element>* p = front->next;//获取第一个多项式的信息
    	int i = 0;
    	while (p)//如果p指向的区域非空
    	{
    		if (p->DATA.a < 0)//如果系数小于零
    		{
    			if (p->DATA.a == (-1))//如果系数小于零且等于-1
    			{
    				cout << "-";
    				if (p->DATA.e != 0 && p->DATA.e != 1)//如果指数为非0或非1
    				{
    					cout << "X^" << p->DATA.e << " ";
    				}
    				else if (p->DATA.e == 1)//如果指数为1
    				{
    					cout << "X";
    				}
    				p = p->next;
    			}
    			else//如果系数
    			{
    				cout << p->DATA.a;
    				if (p->DATA.e != 0 && p->DATA.e != 1)
    				{
    					cout << "X^" << p->DATA.e << " ";
    				}
    				else if (p->DATA.e == 1)
    				{
    					cout << "X";
    				}
    				p = p->next;
    			}
    
    		}
    		else if (p->DATA.a == 0)//系数等于零直接跳过
    		{
    			p = p->next;
    		}
    		else//系数为正
    		{
    			if (i == 0)//如果是第一个,不用输出正号
    			{
    				if (p->DATA.a == 1)
    				{
    					if (p->DATA.e != 0 && p->DATA.e != 1)
    					{
    						cout << "X^" << p->DATA.e << " ";
    					}
    					else if (p->DATA.e == 1)
    					{
    						cout << "X";
    					}
    					p = p->next;
    				}
    				else//系数不为1
    				{
    					cout << p->DATA.a;
    					if (p->DATA.e != 0 && p->DATA.e != 1)
    					{
    						cout << "X^" << p->DATA.e << " ";
    					}
    					else if (p->DATA.e == 1)
    					{
    						cout << "X ";
    					}
    					p = p->next;
    				}
    				i++;
    			}
    			else//不是第一个要输出+
    			{
    				if (p->DATA.a == 1)
    				{
    					if (p->DATA.e != 0 && p->DATA.e != 1)
    					{
    						cout << "+X^" << p->DATA.e << " ";
    					}
    					else if (p->DATA.e == 1)
    					{
    						cout << "+X" << " ";
    					}
    					p = p->next;
    				}
    				else//系数不为1
    				{
    					cout << "+" << p->DATA.a;
    					if (p->DATA.e != 0 && p->DATA.e != 1)
    					{
    						cout << "X^" << p->DATA.e << " ";
    					}
    					else if (p->DATA.e == 1)
    					{
    						cout << "X";
    					}
    					p = p->next;
    				}
    			}
    		}
    	}
    	cout << endl;
    }
    
    
    int main()
    {
    	//操作界面
    	int choose;
    	cout << " *********************************************************************************************" << endl << endl;;
    	cout << "          注:请按升幂次序依次输入多项式各项的系数和指数   如:X+8X^2   您可输入:1 1 8 2" << endl;
    	cout << "                              多项式相加请输入                 1" << endl;
    	cout << "                              多项式相减请输入                 2" << endl;
    	cout << "                              多项式求导请输入                 3" << endl;
    	cout << "                              多项式求某个值请输入             4" << endl;
    	cout << "                              多项式相乘请输入                 5" << endl;
    	cout << "                              退出请输入                       0" << endl;
    	cout << "***********************************************************************************************" << endl;
    	
    	do
    	{
    		cout << "请输入您的操作(数字):";
    		cin >> choose;
    		switch (choose)
    		{
    		case 0:break;
    		case 1:
    		{//多项式相加
    
    		//首先完成多项式链表的构建
    			cout << "请输入第一组多项式:";
    			int a = 0, e = 0; int i = 0;
    			element* s = new element[100];
    			do 
    			{
    				cin >> a >> e;
    				s[i].a = a;
    				s[i].e = e;
    				i++;
    			} while (getchar() != '\n');
    			TruList aa(s, i + 1);
    			cout << "请输入第二组多项式:";
    			a = 0, e = 0;  i = 0;
    			element* p = new element[100];
    			do
    			{
    				cin >> a >> e;
    				p[i].a = a;
    				p[i].e = e;
    				i++;
    			} while (getchar() != '\n');
    			cout << endl;
    			//相加函数
    			TruList bb(p, i + 1);
    			aa.Add(bb);
    			aa.PrintList();
    			delete[] s;
    			delete[] p;
    
    			cout << endl;
    			break;
    		}
    		case 2://多项式相减
    		{//首先完成多项式链表的构建
    			cout << "请输入第一组多项式:";
    			int a = 0, e = 0; int i = 0;
    			element* s = new element[100];
    			do
    			{
    				cin >> a >> e;
    				s[i].a = a;
    				s[i].e = e;
    				i++;
    			} while (getchar() != '\n');
    			TruList aa(s, i + 1);
    			cout << "请输入第二组多项式:";
    			a = 0, e = 0;  i = 0;
    			element* p = new element[100];
    			do
    			{
    				cin >> a >> e;
    				p[i].a = a;
    				p[i].e = e;
    				i++;
    			} while (getchar() != '\n');
    			cout << endl;
    			//相加函数
    			TruList bb(p, i + 1);
    			aa.Cut(bb);
    			aa.PrintList();
    			delete[] s;
    			delete[] p;
    			cout << endl; 
    			break;
    		}
    		case 3://多项式求导
    		{
    			cout << "请输入要求导的多项式:";
    			int a = 0, e = 0; int i = 0;
    			element* s = new element[100];
    			do
    			{
    				cin >> a >> e;
    				s[i].a = a;
    				s[i].e = e;
    				i++;
    			} while (getchar() != '\n');
    			TruList aa(s, i + 1);
    			cout << endl;
    			aa.Der();
    			aa.PrintList();
    			delete[] s; 
    			break;
    		}
    		case 4:
    		{
    			cout << "请输入要值的多项式:";
    			int a = 0, e = 0; int i = 0;
    			element* s = new element[100];
    			do
    			{
    				cin >> a >> e;
    				s[i].a = a;
    				s[i].e = e;
    				i++;
    			} while (getchar() != '\n');
    			TruList aa(s, i + 1);
    			
    			cout << "请输入您要求的X的值";
    			int m = 0; cin >> m;
    			aa.Sum(m);
    			cout << endl;
    			delete[] s;
    			break;
    		}
    		case 5://多项式相乘
    		{//首先完成多项式链表的构建
    			cout << "请输入第一组多项式:";
    			int a = 0, e = 0; int i = 0;
    			element* s = new element[100];
    			do
    			{
    				cin >> a >> e;
    				s[i].a = a;
    				s[i].e = e;
    				i++;
    			} while (getchar() != '\n');
    			TruList aa(s, i + 1);
    			cout << "请输入第二组多项式:";
    			a = 0, e = 0;  i = 0;
    			element* p = new element[100];
    			do
    			{
    				cin >> a >> e;
    				p[i].a = a;
    				p[i].e = e;
    				i++;
    			} while (getchar() != '\n');
    			TruList bb(p, i + 1);
    			cout << endl;
    			aa.Pro(aa, bb);
    			break;
    		}
    		default: 
    		{
    			cout << "输入错误,注意提示,请重新输入!" << endl;
    		}
            }
    	} while (choose != 0);
    
    }

    展开全文
  • C++多项式相乘

    千次阅读 2020-02-23 16:28:26
    //累加的原因是,因为是两个相加的式子相乘,所以要合并幂次相同的项 } for ( int i = 20 ; i >= 0 ; i -- ) { if ( ans [ i ] != 0 ) { cout ans [ i ] " " i endl ; } } ...
  • 两个多项式相乘

    千次阅读 2012-08-30 21:08:34
    #include #include #define swap(x, y, t) ((t)=(x),(x)=(y),(y)=(t)) #define MAX_SIZE 1000 void readpoly( int *starta, int *startb, int *finisha, int *finishb); void muti(int starta, int startb, int fin
  • 两个多项式相乘求解系数数组算法

    千次阅读 2019-09-27 03:22:08
     给出两个多项式,最高次幂分别为n和m,求解这两个系数相乘得到的系数数组。 分析:  最高次幂如果是m和n,那么他们相乘得到的系数数组的最高次幂一定是n+m,对于其他的系数,不妨设a[],b[]是给定的两个系数数组...
  • 计蒜客-多项式相乘

    2020-04-29 21:02:58
    题目链接:多项式相乘 题目思路:用数组存每指数所对应的系数,题中所说,a,b<=10,所以指数最大为20 #include <bits/stdc++.h> using namespace std; int a[2][2]; //存第一项 int b[2][2];//存第二项...
  • 【问题描述】 编程实现若干个多项式相乘。多项式的输入输出格式为:系数在前,指数在后,各项按指数递增排列,每个多项式输入时以两个0结束。系数为0的项不输出。 例如:1+4X3-9X5  输入格式可以为:1 0 0 1 0 2 4...
  • 链表实现多项式相乘<线性表> 初学数据结构,我这个菜鸟 没看教程完全自己想. 这个题做好了好久.... 输入两个多项式,多项式的第一个数是项数.后续是两两一对,一个系数,一个指数. 多项式有序,按照系数...
  • 两个一元多项式相乘: 如: pa=5X50+15X20+20X10 pb=10X30+20X20+150X2 分析:就是pa中的每一项分别乘以pb的各项,然后合并同类项。 指数公式:AXABXB=ABXA+B 相乘的结果是: pc=50X80+100X70+750X52+ 150X50+300X40...
  • 多项式相乘 数据结构课程设计,含源代码,和详细的实验报告
  • } 程序分析: 运行结果: 实现两个多项式相乘 算法思路:创建两个链表,其中包含数据域(系数、指数),以及指向下一个结点的指针域。将链表中数据域进行相乘后得到新的链表,将新链表按照指数递减的规则排序。定义两...
  • C C++程序设计 求两个一元多项式相乘的算法.txt
  • 多项式相乘 用链表实现
  • 若是当前k值,表明该指数找到了,此时就是a,b都后继一位,因为只有这种组合才可能有同样系数 若是当前指数k,表明要减少系数和,只有b增加 这也就看出了,a,b两个链表指数一个升序一个降序的好处了。这种思路很好 3....
  • 多项式相乘一元稀疏多项式简单计算器的基本功能是: (1)输入并建立多项式; (2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,...,cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序...
  • 先说一下,我用了种方法实现,一种是顺序表实现,一种是链表实现,所以,为了方便,将种方法分别写成头文件了,主函数是一样的 方法一(顺序表实现) 直接上代码,头文件"List.h"代码: //头文件"List.h" #...
  • 数据结构__两个多项式乘法运算

    千次阅读 2018-10-29 13:32:50
    ,也是第一次数据结构课程设计的题目 一共四文件,分别命名为main.cpp head.h list.h cal.h。作用分别是main函数主程序,基本头文件卷入,单链表和其基本操作的定义,计算并合并同类项目操作 注释就不写了,...
  • 数据结构多项式相乘

    2013-04-16 20:23:30
    建立链表表示一个一元多项式,并完成两个多项式的乘法,并输出。
  • BUAA(2021春)多项式相乘

    2021-04-29 17:11:11
    编写一个程序实现两个一元多项式相乘。 输入形式 首先输入第一个多项式中系数不为0的项的系数和指数,以一个空格分隔。且该多项式中各项的指数均为0或正整数,系数和最高幂次不会超过int类型的表示范围。对于多项式 ...
  •  给出两个多项式,求两个多项式的乘积。 注意: 答案的数组至少会取得2000,所以要开到2001. 没必要开两个数组,读完两个多项式之后再处理,读完一个多项式,对于第二个边读边处理。 段错误:越界错误 ...
  • 多项式相乘(链表)

    千次阅读 2019-09-19 19:04:41
    相乘,那就必须把A中的每一项分别和B中的每一项相乘。 所以就是,A中的每一项分别和B中的所有相乘,得到一链表,然后把所有链表相加?感觉能做,但是好麻烦啊。有没有更简单的做法呢? 去网上搜索,emmm,...
  • C语言实现多项式相乘

    2012-11-05 13:57:56
    编程实现若干个多项式相乘。多项式的输入输出格式为:系数在前,指数在后,各项按指数递增排列,每个多项式输入时以两个0结束。系数为0的项不输出。例如:1+4X3-9X5输入格式为:1 0 0 1 0 2 4 3 0 4 -9 5 0 0或者 1 ...
  • 多项式相乘 * 问题描述 此程序解决的是一元多项式相乘的问题。定义两个一元多项式,然后进行两个一元 多项式的相乘。最后得到一个结果,并按升幂输出最终的多项式。 * 设计思路 定义一个结构体,里面包含一元多项式...
  • 多项式相乘

    2020-07-25 20:25:11
    下面种方法计算结果是一致的。 matlab 计算结果 ​f=(x^2+2*x+1)*(2*x^2+x+3) collect(f,x)​ 2*x^4 + 5*x^3 + 7*x^2 + 7*x + 3 conv([1,2,1],[2,1,3]) 2 5 7 7 3
  • /实现n个多项式相乘/ #include “stdio.h” const int N0=20; //常数: 多项式最多20个 typedef struct node{ //多项式的项(链表节点), 数据包含: 项的系数和指数, 下一项的指针. int c, e; //c-系数(coefficient);...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,635
精华内容 4,654
关键字:

两个多项式相乘