PAT 1009. Product of Polynomials (25)

1009. Product of Polynomials (25)

This time, you are supposed to find A*B where A and B are two polynomials.

Input Specification:

Each input file contains one test case. Each case occupies 2 lines, and each line contains the information of a polynomial: K N1 a_N1 N2 a_N2 ... NK a_NK, where K is the number of nonzero terms in the polynomial, Ni and a_Ni (i=1, 2, ..., K) are the exponents and coefficients, respectively. It is given that 1 <= K <= 10, 0 <= NK < ... < N2 < N1 <=1000.

 

Output Specification:

For each test case you should output the product of A and B in one line, with the same format as the input. Notice that there must be NO extra space at the end of each line. Please be accurate up to 1 decimal place.

Sample Input

2 1 2.4 0 3.2
2 2 1.5 1 0.5

Sample Output

3 3 3.6 2 6.0 1 1.6

 

#include <iostream>
#include <vector>
#include <iomanip>

class polynomial
{
private:
	std::vector<double> coefficient;
	std::vector<int> radix;
public:
	polynomial(){}
	polynomial(const polynomial &poly){ *this = poly; }
	~polynomial(){}
	friend polynomial operator+(const polynomial &poly1, const polynomial &poly2);
	friend polynomial operator-(const polynomial &poly1, const polynomial &poly2);
	polynomial& operator+=(const polynomial &poly){ *this = *this + poly; return *this; }
	polynomial& operator-=(const polynomial &poly){ *this = *this - poly; return *this; }
	friend polynomial operator*(const polynomial &poly1, const polynomial &poly2);
	friend std::istream& operator>>(std::istream &is, polynomial &poly);
	friend std::ostream& operator<<(std::ostream &os, const polynomial &poly);
};

polynomial operator+(const polynomial &poly1, const polynomial &poly2)
{
	polynomial polysum;

	int i = 0, j = 0;
	while (i<poly1.radix.size() || j<poly2.radix.size())
	{
		//only poly1
		if (i<poly1.radix.size() && j == poly2.radix.size())
		{
			polysum.radix.push_back(poly1.radix[i]);
			polysum.coefficient.push_back(poly1.coefficient[i]);
			i++;
		}
		//only poly2
		else if (j<poly2.radix.size() && i == poly1.radix.size())
		{
			polysum.radix.push_back(poly2.radix[j]);
			polysum.coefficient.push_back(poly2.coefficient[j]);
			j++;
		}
		//the radix of poly1 greater than poly2
		else if (poly1.radix[i] > poly2.radix[j])
		{
			polysum.radix.push_back(poly1.radix[i]);
			polysum.coefficient.push_back(poly1.coefficient[i]);
			i++;
		}
		//the radix of poly1 smaller than poly2
		else if (poly1.radix[i] < poly2.radix[j])
		{
			polysum.radix.push_back(poly2.radix[j]);
			polysum.coefficient.push_back(poly2.coefficient[j]);
			j++;
		}
		//the radix of poly1 equal to poly2
		else
		{
			if (poly1.coefficient[i] + poly2.coefficient[j] != 0)
			{
				polysum.radix.push_back(poly1.radix[i]);
				polysum.coefficient.push_back(poly1.coefficient[i] + poly2.coefficient[j]);
			}
			i++;
			j++;
		}
	}

	return polysum;
}

polynomial operator-(const polynomial &poly1, const polynomial &poly2)
{
	polynomial negativePoly;

	negativePoly = poly2;
	for (int i = 0; i < negativePoly.coefficient.size(); i++)
		negativePoly.coefficient[i] = -negativePoly.coefficient[i];

	return poly1 + negativePoly;
}

polynomial operator*(const polynomial &poly1, const polynomial &poly2)
{
	polynomial mul;

	int i = 0;
	while (i < poly2.coefficient.size())
	{
		polynomial part = poly1;
		double coefficient = poly2.coefficient[i];
		int radix = poly2.radix[i];

		for (int j = 0; j < part.coefficient.size(); j++)
		{
			part.radix[j] += radix;
			part.coefficient[j] *= coefficient;
		}
		mul += part;
		i++;
	}

	return mul;
}

std::istream& operator>>(std::istream &is, polynomial &poly)
{
	int k;
	is >> k;
	for (int i = 0; i<k; i++)
	{
		double tmpcoe;
		int tmprad;
		is >> tmprad >> tmpcoe;
		poly.radix.push_back(tmprad);
		poly.coefficient.push_back(tmpcoe);
	}

	return is;
}

std::ostream& operator<<(std::ostream &os, const polynomial &poly)
{
	os << poly.radix.size();
	if (poly.radix.size() != 0)
		std::cout << " ";
	for (int i = 0; i<poly.radix.size(); i++)
	{
		os << poly.radix[i] << " " << std::fixed << std::setprecision(1) << poly.coefficient[i];
		if (i != poly.radix.size() - 1)
			os << " ";
	}

	return os;
}

int main()
{
	polynomial poly1, poly2;

	std::cin >> poly1 >> poly2;

	std::cout << poly1*poly2;
}