codevs 3119 高精度练习之大整数开根

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <string>
#include <cmath>
using namespace std;

class BigInt{
friend istream& operator>>(istream &is,BigInt &bi);
friend ostream& operator<<(ostream &is,const BigInt &bi);
private:
vector<int> num; // 存放数字
char sig;
public:
BigInt(){
sig = '+';
}
BigInt operator-(BigInt& other);
BigInt operator/(BigInt& other);  // 大数除法,仅求出算整数部分
BigInt operator+(BigInt& other);  // 大数加,为大数乘法提供帮助
BigInt operator*(BigInt& other);  // 大数乘,为大数乘法提供帮助
BigInt biSqrt();     // 大整数开平方仅求出整数部分 // 二分法求开方
void   divide(BigInt& other,BigInt& result);
unsigned locate(unsigned);
bool less(const BigInt& other);   // A 是否小于 B
bool gt(const BigInt& other);
void delTailZero();
void delHeadZero();
BigInt newtonSqrt();    // 牛顿迭代求开方
void setSig(char s){
sig = s;
}
char getSig() const{
return sig;
}
};

bool BigInt::less(const BigInt& other){
if(num.size() != other.num.size()){
return num.size() < other.num.size();
}
else{
for(unsigned i = 0; i < num.size(); i++){
if(num[i] < other.num[i])
return true;
else if(num[i] > other.num[i])
return false;
}
return false;
}
}

bool BigInt::gt(const BigInt& other){  // 传去比较函数，然后在传入比较器。
if(num.size() != other.num.size()){
return num.size() > other.num.size();
}
else{
for(unsigned i = 0; i < num.size(); i++){
if(num[i] > other.num[i])
return true;
else if(num[i] < other.num[i])
return false;
}
return false;
}
}

unsigned BigInt::locate(unsigned pos){     // 下标转换 o(1)
return pos >= num.size() ? 0 : num[num.size() - pos - 1];
}

void BigInt::delTailZero(){
while (0 == num.back() && num.size() > 1)
{
num.pop_back();
}
}

void BigInt::delHeadZero(){  // 删除头0
reverse(num.begin(),num.end());// n/2
while (num.size() > 1 && 0 == num.back())
{
num.pop_back();
}
reverse(num.begin(),num.end()); // n/2
}

BigInt BigInt::operator+(BigInt& other){
unsigned carry = 0,
larger_size,
partial_sum;

BigInt sum;
if (num.size() > other.num.size())
larger_size = num.size();
else
larger_size = other.num.size();
for (unsigned i = 0; i < larger_size; i++)
{
partial_sum = locate (i) + other.locate(i) +  carry;
carry = partial_sum / 10;
sum.num.push_back (partial_sum % 10);
}
if (carry == 1)
sum.num.push_back (carry);
reverse (sum.num.begin(), sum.num.end());
return sum;

}

BigInt BigInt::operator-(BigInt& other)
{
BigInt result,
*bigger = this,
*little = &other;

unsigned borrow = 0;

if((*this).less(other)){
bigger = &other;
little = this;
result.setSig('-');
}

unsigned bi = 0,
li = 0;

for(unsigned i = 0; i < (*bigger).num.size(); i++){
bi = (*bigger).locate(i);
li = (*little).locate(i);
if(bi < li + borrow){
result.num.push_back(bi+10 - li - borrow);
borrow = 1;
}else{

result.num.push_back(bi - li - borrow);
borrow = 0;
}
}
result.delTailZero();
reverse(result.num.begin(),result.num.end());
return result;
}

BigInt BigInt::operator*(BigInt& other){
BigInt interResult,
result;        //  12938 A
unsigned carry = 0;    //*   123 B
for (unsigned i = 0 ; i < other.num.size(); i++)   // B
{
carry = 0;
unsigned tmpi = i;
interResult.num.clear();  // 计算前，将中间结果清除。
while (tmpi > 0)
{
interResult.num.push_back(0);
tmpi--;
}
for (unsigned j = 0; j < num.size(); j++)  // A
{
unsigned product = other.locate(i) * locate(j) + carry;
carry = product / 10;
interResult.num.push_back(product%10);   // 保存临时结果
}
if (carry > 0)
{
interResult.num.push_back(carry);
}
reverse(interResult.num.begin(),interResult.num.end());
result = interResult + result;
}
return result;
}

BigInt BigInt::operator/(BigInt& other){
// 仅仅保留整数部分 A > B , A == B A < B 。 所以有这三种情况。 A >= B 进行除法运算。
BigInt result;  // 截取一段去除 other
BigInt tmp;
unsigned index = 0;
unsigned quotient = 0;  // 商
bool contact = false;
if((*this).less(other)){
result.num.push_back(0);
}else{ // 进行除法运算
index = other.num.size();  // 构造一个长度为 len的临时对象
tmp.num.assign(num.begin(),num.begin()+index);
if (index == num.size())                // 小于，大于，== 三个操作
{
while(!tmp.less(other)){
quotient++;
tmp = tmp - other; // = 9
}
result.num.push_back(quotient);
}
else
{
while(index < num.size()){
quotient = 0;
while(tmp.less(other)){    // 首先除数肯定比被除数大，若小整数部分肯定为了，所以追加数字，住

if(index < num.size()){
if(contact == true)            // 当一次拼接完成后，才判断是商0，还是商1.
result.num.push_back(0);   // 小于某数补0;
tmp.num.push_back(num.at(index));
contact = true;
}
else{
break;
}
index += 1;
}
contact = false;
tmp.delHeadZero();
while(!tmp.less(other)){
quotient++;
tmp = tmp - other; // = 9
}
tmp.delHeadZero();
if(index <= num.size())  // 这里是 <=  而上面是小于 因为上面完成了index += 1 操作，所以这里少1。
result.num.push_back(quotient);
}
}
}
return result;
}

istream& operator>>(istream &is,BigInt &bi)
{
const char lOWBOUND = '0';
string num;
is >> num;
for(size_t i = 0; i < num.size(); i++)
bi.num.push_back(num[i] - lOWBOUND);
return is;
}

ostream& operator<<(ostream &os,const BigInt &bi)
{
if(bi.getSig() == '-'){
os <<"-";
}
for(size_t i = 0; i < bi.num.size(); i++){
//os << bi.num[i];
printf("%d",bi.num[i]);
}
return os;
}

BigInt BigInt::newtonSqrt() // 牛顿迭代法求 平方根，仅算整数部分
{
BigInt result,
biTwo,  // 2的大数表示 ,
lastResult;
biTwo.num.push_back(2);
unsigned resultLen = (unsigned)((this->num.size())/2.0 + 0.5); // 开方后数字位数
// 通过手算开放的办法先计算出结果的前5位
int result1 = 0; // 存放计算的中间及结果
int i1 = 0,
n1 = 0,          // 截取的两位数和后面两位
n2 = 0;          // 待减的两位数字

if(this->num.size()>100)  // 大于100位数，预处理。精确算出前5位。
{
if (this->num.size()%2)  // 共偶数位，先取一位算
{
i1 = 1; // 下一次计算从第i位开始

int s = (int)(sqrt(this->num[0]*1.0));
result1 = result1*10 + s;
lastResult.num.push_back(s);
n1 = this->num[0] - s*s;

}
else
{
i1 = 2;
int sum = this->num[0]*10+this->num[1];
int s = (int)(sqrt(sum*1.0));
lastResult.num.push_back(s);
n1 = sum - s*s;
}
for ( ; i1< 8; i1 += 2)  //  只预处理前8位
{
n1 = n1*10 + this->num[i1];
n1 = n1*10 + this->num[i1+1];

n2 = result1*20;
if (n1 < n2 )
{
lastResult.num.push_back(0);
result1 = result1 * 10;  // 不够的话商0（左移一位）
continue;
}
int j = 1;
for (; j <= 9; j++)
{
if ((n2+1)*j > n1)
{
break;
}
else
{
n2++;
}
}
lastResult.num.push_back(n2%10);
result1 = result1*10 + n2%10;

n1 = n1 - n2*(j-1);
}
}
for (unsigned i = (i1/2.0 + 0.5); i < resultLen; i++)  // 构建初始值,前5位由手算除法
{
lastResult.num.push_back(9);
}
while (true)   // 牛顿迭代求 结果
{
BigInt tmp = (*this)/lastResult;
result = (lastResult + tmp)/biTwo;
if(result.less(lastResult))
{
lastResult = result;
}
else
{
break;
}
}
return lastResult;
}

int main(int argc, char** argv) {

BigInt A;
cin >> A;
cout << (A.newtonSqrt())<< endl;
return 0;
}