Ditulis dalam C++, terjemah yang berikut ke dalam bahasa Cina: Kira jumlah sepunya minimum tatasusunan K selepas memadam sebahagian daripada tatasusunan

Apabila menggunakan tatasusunan C++, kadangkala kita perlu mengira jumlah sepunya minimum antara berbilang tatasusunan sambil mengalih keluar sebahagian daripada akhiran mereka. Dalam artikel ini, kami akan meneroka penyelesaian yang cekap untuk masalah ini menggunakan C++.

Tatabahasa

Mari kita menganalisis sintaks kaedah pilihan kami dahulu sebelum meneruskan untuk melaksanakannya dalam kod kami -

int findMinimumCommonSum(vector<vector<int>>& arrays, int suffixToRemove);

Algoritma

Berikut ialah algoritma langkah demi langkah untuk menyelesaikan masalah mencari jumlah sepunya paling kurang selepas memadam sebahagian daripada akhiran tatasusunan -

• Mulakan dengan mentakrifkan fungsi findMinimumCommonSum, yang menerima dua parameter - tatasusunan, vektor dua dimensi yang mewakili tatasusunan dan suffixToRemove, integer yang mewakili bilangan elemen yang akan dialih keluar daripada akhiran setiap tatasusunan.

• Mulakan jumlah minimum pembolehubah untuk menyimpan jumlah sepunya minimum, dan tetapkan nilai permulaannya kepada nilai yang lebih besar.

• Lelaran pada setiap tatasusunan dalam vektor tatasusunan.

• Tentukan saiz tatasusunan semasa.

• Untuk mengelak daripada berakhir dengan tatasusunan kosong, pertimbangkan untuk melangkau suffixToRemove lelaran yang melebihi atau sama dengan jumlah saiz tatasusunan semasa. Mengalih keluar semua aksara dalam kes ini tidak menghasilkan sebarang output yang bermakna.

• Kira jumlah elemen tatasusunan dari indeks 0 hingga saiz - suffixToRemove - 1 dan simpannya dalam currentSum pembolehubah.

• Jika currentSum kurang daripada minimumSum, gunakan nilai currentSum untuk mengemas kini minimumSum.

• Selepas melelaran melalui semua tatasusunan, minimumSum akan mengandungi jumlah sepunya minimum dalam tatasusunan selepas mengalih keluar akhiran yang ditentukan.

Kaedah 1: Brute force cracking

Dalam kaedah ini, kami akan menjana semua kemungkinan gabungan akhiran untuk dialih keluar dan mengira jumlah bagi setiap gabungan. Jumlah terkecil di antara semua kombinasi ialah jumlah sepunya terkecil.

Contoh

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int findMinimumCommonSum(vector<vector<int>>& arrays, int suffixToRemove) {
   int minimumSum = INT_MAX;
   int k = arrays.size();

   for (int i = 0; i < k; i++) {
      int size = arrays[i].size();

      if (suffixToRemove >= size)
         continue;

      vector<bool> suffix(size, false);
      fill(suffix.begin() + size - suffixToRemove, suffix.end(), true);

      do {
         int currentSum = 0;
         
         for (int j = 0; j < k; j++) {
            int arraySum = 0;
            for (int l = 0; l < size; l++) {
               if (!suffix[l])
                  arraySum += arrays[j][l];
            }
            currentSum += arraySum;
         }

         if (currentSum < minimumSum)
            minimumSum = currentSum;

      } while (next_permutation(suffix.begin(), suffix.end()));
   }

   return minimumSum;
}

int main() {
   vector<vector<int>> arrays = {{1, 2, 3},
                                 {4, 5, 6},
                                 {7, 8, 9}};

   int suffixToRemove = 1;

   int minimumCommonSum = findMinimumCommonSum(arrays, suffixToRemove);

   cout << "Minimum Common Sum: " << minimumCommonSum << endl;

   return 0;
}

Output

Minimum Common Sum: 27

Arahan

Dalam kaedah brute force, matlamat kami adalah untuk mencari jumlah sepunya minimum antara berbilang tatasusunan selepas mengalih keluar bilangan elemen tertentu daripada akhiran mereka. Kaedah ini melibatkan penjanaan semua kemungkinan gabungan akhiran yang akan dikeluarkan dan mengira jumlah setiap gabungan. Jumlah terkecil di antara semua kombinasi akan menjadi jumlah sepunya terkecil.

Untuk melaksanakan pendekatan ini, kami mentakrifkan fungsi yang dipanggil findMinimumCommonSum, yang menerima dua parameter: tatasusunan (vektor 2D yang mewakili tatasusunan) dan suffixToRemove (integer mewakili bilangan elemen untuk dialih keluar daripada setiap sufiks tatasusunan).

Di dalam fungsi, kami memulakan pembolehubah minimumSum untuk menyimpan jumlah sepunya minimum, dan nilai permulaan ditetapkan kepada nilai maksimum yang mungkin bagi jenis int. Kemudian kita lelaran melalui setiap tatasusunan dalam vektor tatasusunan. Untuk setiap tatasusunan, kami menentukan saiznya dan menyemak sama ada nilai suffixToRemove kurang daripada saiz.

Jika syarat dipenuhi, kami menggunakan vektor Boolean untuk menjana semua gabungan akhiran yang mungkin. Kami mengisi unsur akhiranToRemove yang terakhir dengan benar dan unsur yang selebihnya dengan palsu. Untuk setiap tatasusunan, kami menentukan saiznya dan menyemak sama ada nilai suffixToRemove kurang daripada saiz.

Kami meneruskan dengan mengira jumlah nilai tatasusunan yang sepadan dengan penunjuk palsu dalam vektor akhiran, untuk setiap gabungan. Kami mengulangi proses ini untuk semua tatasusunan, mengemas kini currentSum dengan sewajarnya.

Akhir sekali, kami membandingkan currentSum dengan minimumSum dan mengemas kini minimumSum jika currentSum lebih kecil. Selepas melelaran melalui semua tatasusunan dan gabungan, minimumSum akan mengandungi jumlah sepunya minimum selepas mengalih keluar akhiran yang ditentukan.

Kaedah 2: Pengisihan yang cekap

Dalam kaedah ini, kami akan mengisih tatasusunan dalam susunan tidak menurun dan mengira jumlah saiz pertama - suffixToRemove elemen setiap tatasusunan. Jumlah terkecil di antara semua tatasusunan akan menjadi jumlah sepunya terkecil.

Contoh

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int findMinimumCommonSum(vector<vector<int>>& arrays, int suffixToRemove) {
   int minimumSum = INT_MAX;
   int k = arrays.size();

   for (int i = 0; i < k; i++) {
      int size = arrays[i].size();

      if (suffixToRemove >= size)
         continue;

      sort(arrays[i].begin(), arrays[i].end());

      int currentSum = 0;
      for (int j = 0; j < size - suffixToRemove; j++)
         currentSum += arrays[i][j];

      if (currentSum < minimumSum)
         minimumSum = currentSum;
   }

   return minimumSum;
}

int main() {
   vector<vector<int>> arrays = {{1, 2, 3},
                                 {4, 5, 6},
                                 {7, 8, 9}};

   int suffixToRemove = 1;

   int minimumCommonSum = findMinimumCommonSum(arrays, suffixToRemove);

   cout << "Minimum Common Sum: " << minimumCommonSum << endl;
   
   return 0;
}

Output

Minimum Common Sum: 3

Arahan

Dalam kaedah pengisihan yang cekap, matlamat kami adalah untuk mencari jumlah sepunya minimum antara berbilang tatasusunan selepas mengalih keluar bilangan elemen tertentu daripada akhiran. Kaedah ini mengambil kesempatan daripada fakta bahawa menyusun tatasusunan memudahkan pengiraan jumlah minimum.

Untuk melaksanakan pendekatan ini, kami mentakrifkan fungsi yang dipanggil findMinimumCommonSum, yang menerima dua parameter: tatasusunan (vektor 2D yang mewakili tatasusunan) dan suffixToRemove (integer mewakili bilangan elemen untuk dialih keluar daripada setiap sufiks tatasusunan).

Di dalam fungsi, kami memulakan pembolehubah minimumSum untuk menyimpan jumlah sepunya minimum, dan nilai permulaan ditetapkan kepada nilai maksimum yang mungkin bagi jenis int. Kemudian kita lelaran melalui setiap tatasusunan dalam vektor tatasusunan. Untuk setiap tatasusunan, kami menentukan saiznya dan menyemak sama ada nilai suffixToRemove kurang daripada saiz.

Apabila prasyarat ini dipenuhi, salah satu langkah kami yang seterusnya ialah mengisih semua komponen individu dalam tatasusunan kami dalam tertib menaik, terutamanya membantu memastikan objek yang lebih kecil berada di bahagian awalnya untuk memperbaik susunan dan kebolehbacaan.

Seterusnya, kami mengira jumlah saiz pertama - unsur suffixToRemove dalam tatasusunan yang diisih. Ini sepadan dengan mengalih keluar bilangan unsur yang ditentukan daripada akhiran. Kami mengemas kini currentSum dengan sewajarnya.

Akhir sekali, kami membandingkan currentSum dengan minimumSum dan mengemas kini minimumSum jika currentSum lebih kecil. Selepas lelaran melalui semua tatasusunan, minimumSum akan mengandungi jumlah biasa minimum selepas mengalih keluar akhiran yang ditentukan.

Kaedah ini sangat cekap kerana ia tidak memerlukan penjanaan dan pengulangan semua kombinasi yang mungkin seperti kaedah brute force. Sebaliknya, ia mengeksploitasi sifat pesanan untuk memudahkan pengiraan jumlah minimum, sekali gus meningkatkan prestasi.

Kesimpulan

Dalam artikel ini, kami meneroka cara yang cekap untuk mencari jumlah sepunya minimum antara tatasusunan K dalam C++ selepas mengalih keluar sebahagian daripada akhiran mereka. Kami membincangkan dua kaedah - kekerasan dan pengisihan yang cekap. Kaedah brute force melibatkan penjanaan semua kombinasi akhiran, manakala kaedah isihan cekap menyusun tatasusunan dan mengira jumlah beberapa elemen pertama. Bergantung pada saiz tatasusunan dan bilangan unsur akhiran yang akan dialih keluar, isihan cekap biasanya lebih cekap. Dengan melaksanakan kaedah ini dalam program C++, anda boleh mencari jumlah sepunya terkecil daripada berbilang tatasusunan dan mengendalikan penyingkiran akhiran dengan cekap.

Atas ialah kandungan terperinci Ditulis dalam C++, terjemah yang berikut ke dalam bahasa Cina: Kira jumlah sepunya minimum tatasusunan K selepas memadam sebahagian daripada tatasusunan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!