这种做法能上题解吗

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


const double INPUT_SCALE = 1.0e+09;
const double OUTPUT_SCALE = 2.0e+09;


const int INPUT_SIZE = 2;
const int HIDDEN_NEURONS = 4;
const int OUTPUT_SIZE = 1;


double W_h[HIDDEN_NEURONS][INPUT_SIZE] = {
    {-1.767773468946937446e-02, -7.793268792037753856e-02},
    {4.668311065397106052e-01, 5.210749660791885729e-01},
    {-1.919635612596087004e-01, -1.793967120896731160e-01},
    {3.403902268165061584e-01, 2.396881132551242632e-01},
};

double b_h[HIDDEN_NEURONS] = {
    1.786500176221633972e-06,
    -3.299220219965260260e-03,
    1.042906958960767476e-03,
    -2.534605147607068600e-03
};


double W_o[OUTPUT_SIZE][HIDDEN_NEURONS] = {
    {-7.701013140847089156e-02, 6.819291288309156096e-01, -2.647350405669287587e-01, 3.803676314921620172e-01},
};

double b_o[OUTPUT_SIZE] = {
    3.490147721887215670e-03
};

double predict(double network_input_a_scaled, double network_input_b_scaled) {
    double inputs_scaled[INPUT_SIZE] = {network_input_a_scaled, network_input_b_scaled};
    double hidden_layer_output[HIDDEN_NEURONS];

    for (int i = 0; i < HIDDEN_NEURONS; ++i) {
        double weighted_sum = 0;
        for (int j = 0; j < INPUT_SIZE; ++j) {
            weighted_sum += W_h[i][j] * inputs_scaled[j];
        }
        weighted_sum += b_h[i];
        hidden_layer_output[i] = weighted_sum;
    }

    double output_layer_value_scaled[OUTPUT_SIZE];

    for (int i = 0; i < OUTPUT_SIZE; ++i) {
        double weighted_sum = 0;
        for (int j = 0; j < HIDDEN_NEURONS; ++j) {
            weighted_sum += W_o[i][j] * hidden_layer_output[j];
        }
        weighted_sum += b_o[i];
        output_layer_value_scaled[i] = weighted_sum; 
    }

    return output_layer_value_scaled[0]; 
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);

    long long input_a_orig, input_b_orig;

    if (!(std::cin >> input_a_orig >> input_b_orig)) {
        return 1; 
    }

    double model_input_a_scaled = static_cast<double>(input_a_orig) / INPUT_SCALE;
    double model_input_b_scaled = static_cast<double>(input_b_orig) / INPUT_SCALE;

    double prediction_scaled = predict(model_input_a_scaled, model_input_b_scaled);

    double prediction_reconstructed = prediction_scaled * OUTPUT_SCALE;

    long long result = static_cast<long long>(std::round(prediction_reconstructed));

    std::cout << result << std::endl;

    return 0;
}