dalao们可以走了

众所周知，我们在写高精度时蜜汁调参非常容易把人累死

所以为了一劳永逸，本人做了一个高精类，在此奉上代码

缺点：没有高精除、高精模、高精与低精混运算，无法处理负数，无压位/二进制优化，O(n2)高精乘

主要是太懒不想继续写了，但蓝题及以下是够用了

烂码轻喷

#include<vector>
#include<string.h>
#include<string>
#include<algorithm>
#include<cmath>
template<typename t>
static t max(t a,t b){
   return std::max(a,b);
}
template<typename t>
static t min(t a,t b){
   return std::min(a,b);
}
class unlint{
private:
   std::vector<unsigned short> cun;
   friend unlint operator+(const unlint& a,const unlint& b);
   friend unlint operator*(const unlint& a,const unlint& b);
   friend unlint operator-(const unlint& a,const unlint& b);
   friend bool operator<(const unlint& a,const unlint& b);
   friend bool operator>(const unlint& a,const unlint& b);
   friend bool operator==(const unlint& a,const unlint& b);
   friend bool operator<=(const unlint& a,const unlint& b);
   friend bool operator>=(const unlint& a,const unlint& b);
public:
   unlint(std::string in){
   	cun.clear();
   	for(unsigned i=in.size();i>0;i--){
   		cun.push_back(in[i-1]-'0');
   	}
   }
   unlint(unsigned in=0){
   	cun.clear();
   	while(in){
   		cun.push_back(in%10);
   		in/=10;
   	}
   	if(!cun.size())cun.push_back(0);
   }
   ~unlint(){
   	cun.clear();
   }
   unsigned short& operator[](unsigned in){
   	return cun[cun.size()-in-1];
   }
   void clear(){
   	cun.clear();
   	cun.push_back(0);
   }
   void rbigenzero(){
   	while(cun.size() and !cun[cun.size()-1]){
   		cun.erase(cun.begin()+cun.size()-1);
   	}
   	if(!cun.size())cun.push_back(0);
   }
   unsigned len(){
   	return cun.size();
   }
   std::string getstr(){
   	std::string out;
   	for(unsigned i=cun.size();i>0;i--){
   		out+=cun[i-1]+'0';
   	}
   	return out;
   }
   unsigned getint(){
   	unsigned out=0;
   	unsigned tenp=1;
   	for(unsigned i=0;i<cun.size();i++){
   		out+=tenp*cun[i];
   		tenp*=10;
   	}
   	return out;
   }
   unlint operator+=(const unlint& b){
   	unsigned len=max(cun.size(),b.cun.size());
   	cun.resize(len+1);
   	for(unsigned i=0;i<len;i++){
   		if(i<b.cun.size())cun[i]+=b.cun[i];
   		if(cun[i]>=10){
   			cun[i+1]++;
   			cun[i]-=10;
   		}
   	}
   	this->rbigenzero();
   	return *this;
   }
   unlint operator-=(const unlint& b){
   	unsigned len=max(cun.size(),b.cun.size());
   	cun.resize(len+1);
   	for(unsigned i=0;i<len;i++){
   		cun[i]+=10;
   		if(i<b.cun.size())cun[i]-=b.cun[i];
   		if(cun[i]<10){
   			cun[i+1]--;
   		}else{
   			cun[i]-=10;
   		}
   	}
   	this->rbigenzero();
   	return *this;
   }
   unlint operator*=(const unlint& b){
   	std::vector<unsigned short> c;
   	unsigned len=cun.size()+b.cun.size()-1;
   	c.resize(len+1);
   	for(unsigned i=0;i<cun.size();i++){
   		for(unsigned j=0;j<b.cun.size();j++){
   			c[i+j]+=cun[i]*b.cun[j];
   		}
   	}
   	for(unsigned i=0;i<len;i++){
   		if(c[i]>=10){
   			c[i+1]+=c[i]/10;
   			c[i]%=10;
   		}
   	}
   	cun=c;
   	this->rbigenzero();
   	return *this;
   }
};
bool operator<(const unlint& a,const unlint& b){
   unsigned i=a.cun.size(),j=b.cun.size();
   for(i;i>0;i--){
   	if(a.cun[i-1])break;
   }
   for(j;j>0;j--){
   	if(b.cun[j-1])break;
   }
   if(i!=j)return i<j;
   for(i;i>0;i--){
   	if(a.cun[i-1]!=b.cun[i-1])return a.cun[i-1]<b.cun[i-1];
   }
   return 0;
}
bool operator>(const unlint& a,const unlint& b){
   unsigned i=a.cun.size(),j=b.cun.size();
   for(i;i>0;i--){
   	if(a.cun[i-1])break;
   }
   for(j;j>0;j--){
   	if(b.cun[j-1])break;
   }
   if(i!=j)return i>j;
   for(i;i>0;i--){
   	if(a.cun[i-1]!=b.cun[i-1])return a.cun[i-1]>b.cun[i-1];
   }
   return 0;
}
bool operator<=(const unlint& a,const unlint& b){
   unsigned i=a.cun.size(),j=b.cun.size();
   for(i;i>0;i--){
   	if(a.cun[i-1])break;
   }
   for(j;j>0;j--){
   	if(b.cun[j-1])break;
   }
   if(i!=j)return i<j;
   for(i;i>0;i--){
   	if(a.cun[i-1]!=b.cun[i-1])return a.cun[i-1]<b.cun[i-1];
   }
   return 1;
}
bool operator>=(const unlint& a,const unlint& b){
   unsigned i=a.cun.size(),j=b.cun.size();
   for(i;i>0;i--){
   	if(a.cun[i-1])break;
   }
   for(j;j>0;j--){
   	if(b.cun[j-1])break;
   }
   if(i!=j)return i>j;
   for(i;i>0;i--){
   	if(a.cun[i-1]!=b.cun[i-1])return a.cun[i-1]>b.cun[i-1];
   }
   return 1;
}
bool operator==(const unlint& a,const unlint& b){
   unsigned i=a.cun.size(),j=b.cun.size();
   for(i;i>0;i--){
   	if(a.cun[i-1])break;
   }
   for(j;j>0;j--){
   	if(b.cun[j-1])break;
   }
   if(i!=j)return 0;
   for(i;i>0;i--){
   	if(a.cun[i-1]!=b.cun[i-1])return 0;
   }
   return 1;
}
unlint operator+(const unlint& a,const unlint& b){
   unlint c;
   unsigned len=max(a.cun.size(),b.cun.size());
   c.cun.resize(len+1);
   for(unsigned i=0;i<len;i++){
   	if(i<a.cun.size())c.cun[i]+=a.cun[i];
   	if(i<b.cun.size())c.cun[i]+=b.cun[i];
   	if(c.cun[i]>=10){
   		c.cun[i+1]++;
   		c.cun[i]-=10;
   	}
   }
   c.rbigenzero();
   return c;
}
unlint operator-(const unlint& a,const unlint& b){
   unlint c=a;
   for(unsigned i=0;i<b.cun.size();i++){
   	if(c.cun[i]>=b.cun[i]){
   		c.cun[i]-=b.cun[i];
   	}
   	else{
   		c.cun[i+1]--;
   		c.cun[i]=10+c.cun[i]-b.cun[i];
   	}
   }
   c.rbigenzero();
   return c;
}
unlint operator*(const unlint& a,const unlint& b){
   unlint c;
   unsigned len=a.cun.size()+b.cun.size()-1;
   c.cun.resize(len+1);
   for(unsigned i=0;i<a.cun.size();i++){
   	for(unsigned j=0;j<b.cun.size();j++){
   		c.cun[i+j]+=a.cun[i]*b.cun[j];
   	}
   }
   for(unsigned i=0;i<len;i++){
   	if(c.cun[i]>=10){
   		c.cun[i+1]+=c.cun[i]/10;
   		c.cun[i]%=10;
   	}
   }
   c.rbigenzero();
   return c;
}