View difference between Paste ID: 2KTasY70 and 3j6jj0n0

-#include <map>
+#include <algorithm>
 #include <iostream>
 #include <vector>
 #include <complex>
 #include <functional>
 #include <stdexcept>
 
 using namespace std;
 class LINP
 {
-	typedef map<int/*Index*/, double/*Coeff*/, greater<int> > value_type;
+
 	// Index => Coeff
 	typedef vector<double> cont_type;
-	LINP(): cont() {
+
-		cont[1] = 1;
+
-	};
+	LINP(): cont() {}
-	LINP(int rhs): cont() {
+	LINP(double rhs): cont(1) {
 		cont[0] = rhs;
-	};
+
 
-	LINP operator [](int rhs) const {
+	LINP operator [](size_t rhs) const {
-		LINP tmp;
+		if (rhs == 0)
-		tmp.cont.clear();
+			return LINP(1);
-		tmp.cont[rhs] = getCoeffOfIndex(1);
+
 		while (--rhs != 0)
 			tmp *= *this;
 		return tmp;
 	}
 
-			v.second *= rhs;
+
 		for (auto& v : cont)
 			v *= rhs;
 		return *this;
 	}
 	LINP operator *(double rhs) const {
 		LINP tmp(*this);
 		tmp *= rhs;
 		return tmp;
-	LINP operator *=(const LINP& rhs) const {
+
-		// Unimplimented
+
 	LINP& operator *=(const LINP& rhs) {
 		if (rhs.cont.empty()) {
 			cont.clear();
 			return *this;
 		} else if (this == &rhs) {
 			return *this *= LINP(*this);
 		}
 		shrinkToFit();
 		cont.reserve(rhs.maxIndex() + maxIndex());
-			this->cont[v.first] += v.second;
+
 		LINP tmp(*this);
 		cont.clear();
-
+		for (auto& v : rhs.cont) {
 			if (v != 0)
 				*this += tmp * v;
 			tmp.cont.insert(tmp.cont.begin(), 0);
 		}
 		return *this;
 	}
 	LINP operator *(const LINP& rhs) const {
 		LINP tmp(*this);
-			this->cont[v.first] -= v.second;
+
 		return tmp;
 	}
 
 	LINP& operator +=(const LINP& rhs) {
 		// Seems safe when this == &rhs
 		if (cont.size() < rhs.cont.size())
 			cont.resize(rhs.cont.size());
 		auto it = cont.begin();
 		for (auto& v : rhs.cont)
 			*it++ += v;
-			v.second = -v.second;
+
 	}
 	LINP operator +(const LINP& rhs) const {
 		LINP tmp(*this);
 		tmp += rhs;
-		for (value_type::const_iterator it=rhs.cont.begin();
+
-			it != rhs.cont.end(); ++it)
+
-		{
+
-			if (it->second != 0)
+
-			{
+		if (this == &rhs) {
-				if ((it->second == 1 || it->second == -1) && it->first != 0)
+			cont.clear();
-				{
+		} else {
-					if (it->second < 0)
+			if (cont.size() < rhs.cont.size())
-						cout << '-';
+				cont.resize(rhs.cont.size());
 			auto it = cont.begin();
-				else
+			for (auto& v : rhs.cont)
-					os << it->second;
+				*it++ -= v;
-				if (it->first != 0)
+
-				{
+
-					cout << "x";
+
-					if (it->first != 1)
+
-						cout << '[' << it->first << ']';
+
 		tmp -= rhs;
 		return tmp;
-			os << '+';
+
 	LINP operator -() const {
-		cout << "\b \b";
+
 		for (auto& v : tmp.cont)
 			v = -v;
 		return tmp;
-	int maxIndex() const {
+
-		return cont.begin()->first;
+
 	friend ostream& operator <<(ostream& os, const LINP& rhs) {
-	int minIndex() const {
+		if (rhs.cont.size() > 1) {
-		return cont.rbegin()->first;
+			for (cont_type::size_type idx = rhs.cont.size() - 1; idx != 0; --idx) {
 				double coeff = rhs.cont[idx];
 				if (coeff == 0)
-	double getCoeffOfIndex(int Index) const {
+					continue;
-		value_type::const_iterator it=cont.find(Index);
+				if (coeff < 0) {
-		return it != cont.end() ? it->second : 0;
+					os << "-";
 					if (coeff != -1)
 						os << -coeff;
-	vector<complex<double> > solve() const throw(exception)	{
+				} else {
-		if (maxIndex()>2 || minIndex()<0)
+					os << "+";
-			throw std::exception();
+					if (coeff != 1)
 						os << coeff;
-		result.reserve(maxIndex());
+
-		if (maxIndex()==1)
+				os << 'X';
-			result.push_back(-getCoeffOfIndex(0)/getCoeffOfIndex(1));
+				if (idx != 1)
-		else	// maxPow()==2
+					os << '[' << idx << ']';
-		{
+
-			complex<double> delta=pow(getCoeffOfIndex(1), 2)-4*getCoeffOfIndex(2)*getCoeffOfIndex(0);
+
-			result.push_back((-getCoeffOfIndex(1)+sqrt(delta))/(2*getCoeffOfIndex(2)));
+		if (!rhs.cont.empty()) {
-			result.push_back((-getCoeffOfIndex(1)-sqrt(delta))/(2*getCoeffOfIndex(2)));
+			double coeff = rhs.cont.front();
 			if (coeff != 0) {
 				if (coeff > 0)
 					os << '+';
 				os << coeff;
 			}
-	value_type cont;
+		} else {
 			os << '0';
 		}
 		return os;
 	}
-	LINP linp=LINP()-(LINP()*0.5+1)-1;
+
 	void shrinkToFit() {
 		cont.resize(maxIndex() + 1);
 	}
-	LINP linp2=LINP()[2]+LINP()*2+1;
+
 	size_t maxIndex() const {
 		return distance(find_if(cont.rbegin(), cont.rend(), [] (double coeff) {
 			return coeff != 0;
-	LINP linp3=LINP()[2]+1;
+		}), cont.rend()) - 1;
 	}
 
 	double getCoeffOfIndex(size_t Index) const {
-		<< "x2 = " << result[1].real() << " + " << result[1].imag() << 'i' << endl << endl;
+		return Index > maxIndex() ? cont[Index] : 0;
 	}
 
 	vector<complex<double> > solve() const throw(invalid_argument)	{
 		size_t maxIdx = maxIndex();
 		if (maxIdx > 2)
 			throw invalid_argument("只支持一次和二次多项式");
 		vector<complex<double> > result;
 		result.reserve(maxIdx);
 		if (maxIdx == 1) {
 			result.push_back(-cont[0] / cont[1]);
 		} else {
 			complex<double> delta=pow(cont[1], 2) - 4 * cont[2] * cont[0];
 			result.push_back((+sqrt(delta) - cont[1]) / (2 * cont[2]));
 			result.push_back((-sqrt(delta) - cont[1]) / (2 * cont[2]));
 		}
 		return result;
 	}
 
 	static LINP getX() {
 		LINP x;
 		x.cont.resize(2);
 		x.cont.back() = 1;
 		return x;
 	}
 
 private:
 	cont_type cont;
 };
 
 int main()
 {
 	const static LINP X = LINP::getX();
 	LINP expression = (X + 1)[3];
 	cout << expression;
 
 	LINP linp=X-(X*0.5+1)-1;
 	cout << linp << " = 0" << endl;
 	cout << "X = " << linp.solve().front().real() << endl << endl;
 
 	LINP linp2=X[2] + X*2 + 1;
 	cout << linp2 << " = 0" << endl;
 	cout << "X1 = X2 = " << linp2.solve().front().real() << endl << endl;
 
 	LINP linp3=X[2] + 1;
 	cout << linp3 << " = 0" << endl;
 	vector<complex<double> > result=linp3.solve();
 	cout << "x1 = " << result[0].real() << " + " << result[0].imag() << 'i' << endl
 		 << "x2 = " << result[1].real() << " + " << result[1].imag() << 'i' << endl
 		 << endl;
 }