C++ Susunan nilai yang lebih kecil dalam tatasusunan lain

Dua tatasusunan A dan B disediakan dalam tutorial ini. Sebagai contoh, kita perlu mengeluarkan sebarang pilihatur A supaya indeks di A[ I ] > B[ I ] dimaksimumkan, seperti

Input: A = [12, 22, 41, 13],
B = [1, 20, 10, 12]
Output: 12, 22, 41, 13

Input: A = [2, 5, 9, 7],
B = [1, 12, 4, 54]
Output: 2 7 5 9

Multiple answers can be present in that case we are simply going to print any one of the answers.

Dalam masalah ini, kita perlu memaksimumkan indeks di A[ i ] > B [ i ] , jadi kami akan menyelesaikan masalah ini dengan rakus.

Kaedah untuk mencari penyelesaian

Dalam kaedah ini, kita kini menyusun kedua-dua tatasusunan terlebih dahulu; kita dengan rakus menyemak setiap indeks tatasusunan B supaya A[i] lebih penting daripadanya dan kemudian menambah elemen itu ke dalam vektor.

Contoh

#include <bits/stdc++.h>
using namespace std;
int main(){
    int A[] = { 2, 5, 9, 7 };
    int B[] = { 1, 12, 4, 54 };
    int n = sizeof(A) / sizeof(int); // size of our arrays
    vector<pair<int, int> > A_pair, B_pair;
    /***********************We are linking element to its position***********/
    for (int i = 0; i < n; i++)
        A_pair.push_back({A[i], i});
    for (int i = 0; i < n; i++)
        B_pair.push_back({B[i], i});
    /***********************************************************************/
    /*****Sorting our pair vectors********************/
    sort(A_pair.begin(), A_pair.end());
    sort(B_pair.begin(), B_pair.end());
    int i = 0, j = 0, ans[n];
    memset(ans, -1, sizeof(ans)); // initializing all the elements with value -1
    vector<int> remaining; // this will store our elements which have lesser value than elemnt present in B.
    while (i < n && j < n) {
        // as our array is sorted then if we find any element in
        //current index which has less value than B of current index then
        // automatically it will have less value than other elements of B
        // that&#39;s why we push such indices in remaining otherwise we push element in ans
        if (A_pair[i].first > B_pair[j].first) {
            ans[B_pair[j].second] = A_pair[i].first;
            i++;
            j++;
        }
        else {
            remaining.push_back(i);
            i++;
        }
    }
    j = 0;
    for (int i = 0; i < n; ++i){
        // now if any index of answer is unchanged so that means
        //we need to fill that position with the remaining elements
        if (ans[i] == -1){
            ans[i] = A_pair[remaining[j]].first;
            j++;
        }
    }
    for (int i = 0; i < n; i++) // printing our answer
        cout << ans[i] << " ";
    return 0;
}

Output

2 7 5 9

Penjelasan kod di atas

Dalam pendekatan ini, kami mula-mula memautkan semua elemen ke indeksnya supaya indeks lama mereka masih dikekalkan semasa menyusun. Kami menyusun dua pasangan vektor dan kini kami dengan rakus mencari jawapan sambil menggelungkan melalui dua tatasusunan dan jika kami mendapat indeks A_pair ia mempunyai nilai yang lebih tinggi daripada B_pair jadi kami menyimpannya dalam tatasusunan kami (dan pada kedudukan B_pair) Jika tidak, kerana kami telah mengisih kedua-dua vektor, kami tahu kami tidak akan dapat menggunakan nilai A_pair ini, jadi kami menolak indeks elemen itu ke dalam vektor yang tinggal dan kini kami mengisi tatasusunan dengan bantuan vektor yang tinggal dan mencetak jawab.

Kesimpulan

Dalam tutorial ini kami menyelesaikan masalah untuk mencari pilih atur tatasusunan dengan nilai yang lebih kecil daripada tatasusunan lain. Kami juga mempelajari program C++ untuk masalah ini dan pendekatan lengkap kami untuk menyelesaikannya. Kita boleh menulis program yang sama dalam bahasa lain seperti C, java, python dan bahasa lain. Kami harap anda mendapati tutorial ini membantu.

Atas ialah kandungan terperinci C++ Susunan nilai yang lebih kecil dalam tatasusunan lain. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!