Бинарный поиск с соблюдением теоремы Пифагора

//Pythagorean Triples
 
#include <iostream>
#include <cmath>
using namespace std;
 
int binSearch(int Begin, int End, int s)
{
    int a = (Begin+End) / 2, c, cPow, abPow;
 
    for(int b = a+1; b < End; b++)
    {
        c = s-a-b;
        abPow = pow(a, 2) + pow(b, 2);
        cPow = pow(c, 2);
 
        if(c > b && abPow == cPow)
            return cPow;
    }
 
    cPow = abPow > cPow ? binSearch(Begin, a, s) : binSearch(a, End, s);
 
    return cPow;
}
 
int main()
{
    int N;
    cin >> N;
    int *Ss = new int[N]; // Массив случаев (значений s)
    for(int i = 0; i < N; i++)
        cin >> Ss[i];
 
    for(int i = 0; i < N; i++)
        cout << binSearch(1, Ss[i], Ss[i]) << " ";
 
    delete[] Ss;
 
    return 0;
}

cPow = abPow > cPow ? binSearch(Begin, a, s) : binSearch(a, End, s);

#include<iostream>
#include<cmath>
 
using namespace std;
 
double s;
 
int main()
{
    cout << "Inpu s" << endl;
    cin >> s; //s=a+b+c
 
    double cc, ss;
 
    ss = pow(s, 2); //(s^2)=(a^2)+(b^2)+(c^2)
 
    cc = (ss / 2); //(c^2)=(a^2)+(b^2)
 
    cout << "C^2 =" << cc<<endl;
 
    system("pause");
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
//На input подается число (s), которое является суммой чисел a, b, c, которые предстоит найти.
//Условие следующее:
//a+b+c должно быть равно s (a+b+c = s) и должна соблюдаться теорема Пифагора, то есть 
//(pow(a, 2) + pow(b, 2) = pow(c, 2))
//На output надо вывести pow(c, 2).
//
//На вход числа идут большие (10e+7),
/////////////////////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <iostream>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_from_sum_of_sides_of_right_triangle_set_square_of_hypotenuse
    (
        long long       s,
        long long   &   hyp_square,
        long long   &   aa,
        long long   &   bb,
        long long   &   cc
    )
{
    bool    bool_res    =   s % 2   ==  0;
 
    if( bool_res )
    {
        double  k_max   =       ( 2 - sqrt(3.0)     )
                            /   2 * s;
 
        bool_res        =   k_max   >=  1;
 
        if( bool_res )
        {
            for( long long  k = 1; k < k_max; ++k )
            {
                long long   c           =   s / 2 - k;
                cc                      =   c;
                long long   ab          =   k * s;
                long long   a_plus_b    =   s - c;
                long long   D           =   a_plus_b * a_plus_b - 4 * ab;
                bool_res                =   D   >   0;
 
                if( !bool_res )
                {
                    continue;
                }
 
                long long   sqrt_D  =   long long   (
                                                        sqrt    (
                                                                    double( D )
                                                                )
                                                    );
 
                bool_res            =   D   ==  sqrt_D * sqrt_D;
 
                if( !bool_res )
                {
                    continue;
                }
 
                aa  =   a_plus_b / 2 - long long    (
                                                        sqrt    (
                                                                    double( D / 4 )
                                                                )
                                                    );
                bb  =   ab / aa;
 
                hyp_square  =   c * c;
 
                return  bool_res;
            }//for
        }//if
    }//if
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
template< typename  T >
bool    successfully_input_val( T   &   val )
{
    T_str   str_val;
    char    c   =   0;
    std::cin    >>  str_val;
    std::istringstream  ssin( str_val );
 
    return      ( ssin  >>  val     )   !=  0
            &&  ( ssin  >>  c       )   ==  0;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    long long   const   S_MAX   =   6000000000;
 
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl;
 
        long long   s   =   0;
 
        do
        {
            std::cout   <<  "Введите s <="
                        <<  S_MAX
                        <<  "\t: ";
        }
        while   (
                        !successfully_input_val( s )
                    ||  s   >  S_MAX
                );
 
        long long   c_square    =   0;
        long long   a           =   0;
        long long   b           =   0;
        long long   c           =   0;
 
        if  (
                successfully_from_sum_of_sides_of_right_triangle_set_square_of_hypotenuse
                    (
                        s,
                        c_square,
                        a,
                        b,
                        c
                    )
            )
        {
            std::cout   <<  std::endl
                        <<  "a + b + c\t\t= "
                        <<  a + b + c
                        <<  std::endl
 
                        <<  "с^2\t\t\t= "
                        <<  c_square
                        <<  std::endl
 
                        <<  "a^a + b^b\t\t= "
                        <<  a * a + b * b
                        <<  std::endl
 
                        <<  "a\t\t\t= "
                        <<  a
                        <<  std::endl
 
                        <<  "b\t\t\t= "
                        <<  b
                        <<  std::endl
 
                        <<  "c\t\t\t= "
                        <<  c
                        <<  std::endl
                        <<  std::endl;
        }
        else
        {
            std::cout   <<  "Решения не существует."
                        <<  std::endl;
        }//else
    }//for
}

#include <cmath>
#include <iostream>
#include <cstdlib>
#include <vector>
typedef long long number;
int main() {
    number s;
    std::cout << "Input s: ";
    if(!(std::cin >> s))
        std::cerr << "Error input! " << std::endl;
    if(!(s & 1)) {
        number max_ab = s / 2;
        std::vector<number> vect;
        for(number denominator = 2; denominator <= max_ab; ++denominator)
            if(std::div(s, denominator).rem == 0)
                vect.push_back(denominator);
        for(number idx = 0; idx < vect.size(); ++idx)
            for(number idy = idx + 1; idy < vect.size(); ++idy)
                if(std::pow(vect[idx], 2) + std::pow(vect[idy], 2) == std::pow(s - vect[idx] - vect[idy], 2)) {
                    std::cout << "a = " << vect[idx]           << std::endl;
                    std::cout << "b = " << vect[idy]           << std::endl;
                    std::cout << "c = " << s - vect[idx] - vect[idy] << std::endl;
                    std::cout << std::endl;
                }
    }
}