在 C++ 中最小化给定多项式的根之和

我们得到了一个整数元素数组,表示多项式的系数值。数组的大小将为“n”,即数组中的元素数。多项式的次数总是从 n-1 开始,因为在多项式系列的末尾会有一个常数值。任务是用其他多项式替换系数,以使根之和最小。

让我们看看这个的各种输入输出场景 -

在 - int arr[] = { 2, -1, 4, 9, -1, 10, -5}

Out  - 最小化给定多项式的根之和为:-1 -5 2 4 9 -1 10

解释 - 我们给出了一个包含 7 个元素的整数数组,即多项式幂为 6。因此,我们将实现最小输出为-:-1 * x^6 - 5 * x^5 + 2 * x^4 + 4 * x^3 + 9 * x^2 - 1 * x^1 + 10 这将导致根的最小总和为 -5 和 1。

在 - int arr[] = {3, -2, -1, 4}

Out  - 最小化给定多项式的根之和为:-1 -2 3 4

解释 - 我们给出了一个包含 7 个元素的整数数组,即多项式幂为 6。因此,我们将实现最小输出为-:-1 * x^3 - 2 * x^2 + 3 * x^1 + 4这将导致根的最小总和为 -1。

下面程序中使用的方法如下

  • 输入一个整数元素数组并计算数组的大小。将数据传递给函数进行进一步处理。

  • 函数内部 Minimize_root(arr, size)

    • 将整数类型向量类型的变量声明为 vec_1、vec_2、vec_3。

    • 从 i 到 0 开始循环 FOR 直到数组的大小。在循环内,检查 IF arr[i] > 0 然后 push_back i 到 vec_2。否则,如果 arr[i] < 0,则 puch_back i 到 vec_3。

    • 计算 vec_2 和 vec_3 的大小。

    • 检查 IF vec_2_size >= 2 AND IF vec_3_size>= 2 然后开始循环 FOR 从 i 到 0 直到 vec_2 的大小和循环内部,检查 IFarr[vec_2[i]] 大于 max_val 然后将 temp 设置为 vec_2[i] 和max_val 到 arr[temp]。

    • 从 i 到 0 开始循环 FOR 直到 vec_2 的大小。在循环内部,检查 IF arr[vec_2[i]] 小于 min_val 比检查 IF vec_2[i] 不等于 temp 然后将 temp_2 设置为 vec_2[i] 并将 min_val 设置为 arr[temp_2]

    • 从 i 到 0 开始循环 FOR,直到 vec_3 的大小。在循环内部,检查 IF abs(arr[vec_3[i]]) 大于 N_max 然后将 N_temp 设置为 vec_3[i] 并将 N_max 设置为 abs(arr[N_temp])

    • 开始循环 FOR 从 i 到 0 直到 vec_3 大小并检查 IF abs(arr[vec_3[i]]) 小于 N_min 比检查 IFvec_3[i] 不等于 N_temp 然后将 N_temp_2 设置为 vec_3[i] 和 N_min = abs(arr [N_temp_2])

    • 检查 IF vec_2_data 小于 vec_3_data 然后在 FOR 循环内从 i 到 0 直到数组的大小,检查 IF i 不等于 temp_2 AND i 不等于 temp 然后 push_back arr[i] 到 vec_1。否则,在从 i 到 0 直到数组大小的 FOR 循环内,检查 IF i 不等于 N_temp_2 AND i 不等于 N_temp 然后 push_back arr[i] 到 vec_1。

    • 开始循环 FOR 以遍历 vec_1 并继续打印 vec_1[i] 结果。

    • 否则,检查 vec_2_size >= 2 然后开始循环 FOR 从 i 到 0 直到 vec_2 的大小。检查如果 arr[vec_2[i]] 大于 max_val,然后将 temp 设置为 vec_2[i] 并将 max_val 设置为 arr[temp]。

    • 从 i 到 0 开始循环 FOR,直到 i 小于 vec_2 的大小。在循环内,检查 IF arr[vec_2[i]] 小于 min_val 比检查 IFvec_2[i] 不等于 temp 比将 temp_2 设置为 vec_2[i] 并将 min_val 设置为 arr[temp_2]。

    • 从 i 到 0 开始循环 FOR 直到数组的大小。在循环内,检查 IF i 不等于 temp_2,然后检查 IF i 不等于 temp,然后 puch_back arr[i] 到 vec_1。

    • ELSE IF, vec_3 >= 2 然后开始循环 FOR 从 i 到 0 直到 vec_3 大小并检查 IF abs(arr[vec_3[i]]) 大于 N_max 然后将 temp 设置为 vec_3[i] 并将 N_max 设置为 abs(arr[temp ])。

    • 开始循环 FOR 从 i 到 0 直到 i 小于 vec_并检查 IF abs(arr[vec_3[i]]) 小于 N_min 比检查 IF vec_3[i] 不等于 temp 比将 temp_2 设置为 vec_3[i] 并将 N_min 设置为abs(arr[temp_2])。3.size()

    • 从 i 到 0 开始循环 FOR 直到数组的大小。检查 IF i 不等于 temp_2 然后检查 IF i 不等于 temp 然后 push_back arr[i] 到 vc_1 并继续打印。

示例

#include <bits/stdc++.h>
using namespace std;
void Minimize_root(int arr[], int size){
   vector<int> vec_1;
   vector<int> vec_2;
   vector<int> vec_3;
   for (int i = 0; i < size; i++){
      if (arr[i] > 0){
         vec_2.push_back(i);
      }
      else if (arr[i] < 0){
         vec_3.push_back(i);
      }
   }
int vec_2_size = vec_2.size();
int vec_3_size = vec_3.size();

if(vec_2_size >= 2){
   if(vec_3_size>= 2){
      int max_val = INT_MIN; //max_val
      int temp = -1; //temp
      int min_val = INT_MAX; //min_val
      int temp_2 = -1; //temp_2
      int N_max = INT_MIN; // N_max
      int N_temp = -1; // N_temp
      int N_min = INT_MAX; //N_min
      int N_temp_2 = -1; //N_temp_2

      for (int i = 0; i < vec_2.size(); i++){
         if (arr[vec_2[i]] > max_val){
            temp = vec_2[i];
            max_val = arr[temp];
         }
      }

      for (int i = 0; i < vec_2.size(); i++){
         if (arr[vec_2[i]] < min_val){
            if(vec_2[i] != temp){
               temp_2 = vec_2[i];
               min_val = arr[temp_2];
            }
         }
      }
      for (int i = 0; i < vec_3.size(); i++){
         if (abs(arr[vec_3[i]]) > N_max){
            N_temp = vec_3[i];
            N_max = abs(arr[N_temp]);
         }
      }
      for (int i = 0; i < vec_3.size(); i++){
         if(abs(arr[vec_3[i]]) < N_min ){
               if(vec_3[i] != N_temp){
                  N_temp_2 = vec_3[i];
                  N_min = abs(arr[N_temp_2]);
               }
          }
      }

      double vec_2_data = -1.0 * (double)max_val / (double)min_val;
      double vec_3_data = -1.0 * (double)N_max / (double)N_min;

      if (vec_2_data < vec_3_data){
         vec_1.push_back(arr[temp_2]);
         vec_1.push_back(arr[temp]);
         for (int i = 0; i < size; i++){
            if (i != temp_2 && i != temp){
               vec_1.push_back(arr[i]);
            }
         }
      }
      else{
         vec_1.push_back(arr[N_temp_2]);
         vec_1.push_back(arr[N_temp]);

         for (int i = 0; i < size; i++){
            if (i != N_temp_2 && i != N_temp){
               vec_1.push_back(arr[i]);
             }
         }
      }
      for (int i = 0; i < vec_1.size(); i++){
         cout << vec_1[i] << " ";
      }
   }
}
else if(vec_2_size >= 2){
   int max_val = INT_MIN;
   int temp = -1;
   int min_val = INT_MAX;
   int temp_2 = -1;
   for (int i = 0; i < vec_2.size(); i++){
      if (arr[vec_2[i]] > max_val){
         temp = vec_2[i];
         max_val = arr[temp];
      }
   }
   for (int i = 0; i < vec_2.size(); i++){
      if (arr[vec_2[i]] < min_val){
         if(vec_2[i] != temp){
            temp_2 = vec_2[i];
            min_val = arr[temp_2];
         }
      }
   }
   vec_1.push_back(arr[temp_2]);
   vec_1.push_back(arr[temp]);
   int i = 0; 
   i < size; i++; {
      if(i != temp_2){
         if(i != temp){
            vec_1.push_back(arr[i]);
         }
      }
   }
   for (int i = 0; i < vec_1.size(); i++){
      cout << vec_1[i] << " ";
   }
}
else if(vec_3_size >= 2){
   int N_max = INT_MIN;
   int temp = -1;
   int N_min = INT_MAX;
   int temp_2 = -1;
   for (int i = 0; i < vec_3.size(); i++){
      if (abs(arr[vec_3[i]]) > N_max){
         temp = vec_3[i];
         N_max = abs(arr[temp]);
      }
   }
   for (int i = 0; i < vec_3.size(); i++){
      if(abs(arr[vec_3[i]]) < N_min){
         if(vec_3[i] != temp){
            temp_2 = vec_3[i];
            N_min = abs(arr[temp_2]);
         }
      }
   }
   vec_1.push_back(arr[temp_2]);
   vec_1.push_back(arr[temp]);
   for (int i = 0; i < size; i++){
         if (i != temp_2){
            if(i != temp){
               vec_1.push_back(arr[i]);
            }
         }
      }
      for (int i = 0; i < vec_1.size(); i++){
         cout << vec_1[i] << " ";
      }
   } else {
      cout<<"Not Possible";
   }
}
int main(){
   int arr[] = { 2, -1, 4, 9, -1, 10, -5};
   int size = sizeof(arr) / sizeof(arr[0]);
   cout<<"最小化给定多项式的根之和为: ";
   Minimize_root(arr, size);
   return 0;
}
输出结果

如果我们运行上面的代码,它将生成以下输出

最小化给定多项式的根之和为: -1 -5 2 4 9 -1 10

猜你喜欢