ลดจำนวนรากของพหุนามที่กำหนดให้น้อยที่สุดใน C++

เราได้รับอาร์เรย์ขององค์ประกอบจำนวนเต็มที่แสดงค่าสัมประสิทธิ์ของพหุนาม ขนาดของอาร์เรย์จะเป็น 'n' นั่นคือจำนวนองค์ประกอบในอาร์เรย์ ดีกรีของพหุนามเริ่มต้นด้วย n-1 เสมอ เนื่องจากจะมีค่าคงที่หนึ่งค่าที่ส่วนท้ายของอนุกรมพหุนาม ภารกิจคือการแทนที่สัมประสิทธิ์ด้วยพหุนามอื่น ๆ ในลักษณะที่จะลดจำนวนรากลง

ให้เราดูสถานการณ์อินพุตเอาต์พุตต่างๆ สำหรับสิ่งนี้ -

ใน − int arr[] ={ 2, -1, 4, 9, -1, 10, -5}

ออก − ลดจำนวนรากของพหุนามที่กำหนดให้น้อยที่สุดคือ:-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}

ออก − ลดจำนวนรากของพหุนามที่กำหนดให้น้อยที่สุดคือ:-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

  • เริ่มลูป FOR จาก i ถึง 0 จนถึงขนาดของอาร์เรย์ ภายในลูป ให้ตรวจสอบ IF arr[i]> 0 จากนั้นกด back i ไปที่ vec_2 มิฉะนั้น IF, arr[i] <0 จากนั้น puch_back i ไปที่ vec_3

  • คำนวณขนาดของ vec_2 และ vec_3

  • ตรวจสอบ IF vec_2_size>=2 และ IF vec_3_size>=2 จากนั้นเริ่มลูป FOR จาก i ถึง 0 จนถึงขนาดของ vec_2 และภายในลูป ตรวจสอบ IFarr[vec_2[i]] มากกว่า max_val จากนั้นตั้งค่า temp เป็น vec_2[i] และ max_val ถึง arr[ชั่วคราว].

  • เริ่มวนซ้ำ FOR จาก i ถึง 0 จนถึงขนาดของ vec_2 ภายในลูป ให้ตรวจสอบ IF arr[vec_2[i]] น้อยกว่า min_val ให้ตรวจสอบ IF vec_2[i] ไม่เท่ากับ temp จากนั้นตั้งค่า temp_2 เป็น vec_2[i] และ min_val เป็น arr[temp_2]

  • เริ่มวนซ้ำ FOR จาก i ถึง 0 จนถึงขนาดของ 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])

  • ตรวจสอบว่า vec_2_data น้อยกว่า vec_3_data จากนั้นอยู่ในวง FOR จาก i ถึง 0 จนถึงขนาดของอาร์เรย์ ตรวจสอบว่า i ไม่เท่ากับ temp_2 และ i ไม่เท่ากับ temp แล้วจึงกด push_back arr[i] ถึง vec_1 มิฉะนั้น ภายใน FOR ลูปตั้งแต่ i ถึง 0 จนถึงขนาดของอาร์เรย์ ให้ตรวจสอบว่า i ไม่เท่ากับ N_temp_2 และ i ไม่เท่ากับ N_temp จากนั้นกด back_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]

  • เริ่มวนรอบ FOR จาก i ถึง 0 จนถึง i น้อยกว่าขนาดของ vec_2 ภายในลูป ให้ตรวจสอบ IF arr[vec_2[i]] น้อยกว่า min_val กว่าตรวจสอบ IFvec_2[i] ไม่เท่ากับ temp มากกว่าที่ตั้งค่า temp_2 เป็น vec_2[i] และ min_val เป็น arr[temp_2]

  • เริ่มลูป FOR จาก i ถึง 0 จนถึงขนาดของอาร์เรย์ ภายในลูป ให้ตรวจสอบว่า ฉันไม่เท่ากับ temp_2 แล้ว ตรวจสอบว่า ฉันไม่เท่ากับ 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 น้อยกว่า tha vec_3.size() และตรวจสอบ IFabs(arr[vec_3[i]]) น้อยกว่า N_min กว่าการตรวจสอบ IF vec_3[i] ไม่เท่ากับ temp กว่าที่ตั้ง temp_2 เป็น vec_3[i] และ N_min ถึง abs(arr[temp_2])

  • เริ่มลูป FOR จาก i ถึง 0 จนถึงขนาดของอาร์เรย์ ตรวจสอบว่า ฉันไม่เท่ากับ temp_2 หรือไม่ จากนั้นตรวจสอบว่า ฉันไม่เท่ากับ 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 the sum of roots of a given polynomial is: ";
   Minimize_root(arr, size);
   return 0;
}

ผลลัพธ์

หากเรารันโค้ดด้านบน มันจะสร้างผลลัพธ์ต่อไปนี้

Minimize the sum of roots of a given polynomial is: -1 -5 2 4 9 -1 10