Encuentre el valor mínimo de una array asociada con otra array

Dada una array de enteros A[] y una array de caracteres B[] de igual longitud donde cada carácter de la array es del conjunto {‘a’, ‘b’, ‘c’} . Los elementos de ambas arrays están asociados entre sí, es decir, el valor de B[i] está vinculado a A[i] para todos los valores válidos de i . La tarea es encontrar el valor min(a + b, c) .
 

Ejemplos: 

Entrada: A[] = {3, 6, 4, 5, 6}, B[] = {‘a’, ‘c’, ‘b’, ‘b’, ‘a’} Salida 
: 6

Entrada: A[] = {4, 2, 6, 2, 3}, B[] = {‘b’, ‘a’, ‘c’, ‘a’, ‘b’} Salida 
: 5  

Enfoque: Para minimizar el valor requerido, los valores de a , b y c deben minimizarse. Entonces, recorra la array y encuentre los valores mínimos de a , b y c asociados con estos caracteres en la array de enteros y finalmente devuelva min(a + b, c) .
A continuación se muestra la implementación del enfoque anterior: 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to get the minimum required value
int getMinimum(int A[], char B[], int n)
{
 
    // To store the minimum values
    // of 'a', 'b' and 'c'
    int minA = INT_MAX;
    int minB = INT_MAX;
    int minC = INT_MAX;
 
    // For every value of A[]
    for (int i = 0; i < n; i++) {
        switch (B[i]) {
 
        // Update the minimum values of 'a',
        // 'b' and 'c'
        case 'a':
            minA = min(A[i], minA);
            break;
        case 'b':
            minB = min(A[i], minB);
            break;
        case 'c':
            minC = min(A[i], minC);
            break;
        }
    }
 
    // Return the minimum required value
    return min(minA + minB, minC);
}
 
// Driver code
int main()
{
    int A[] = { 4, 2, 6, 2, 3 };
    char B[] = { 'b', 'a', 'c', 'a', 'b' };
 
    int n = sizeof(A) / sizeof(A[0]);
 
    cout << getMinimum(A, B, n);
}

// Java implementation of the above approach
class GFG
{
 
// Function to get the minimum required value
static int getMinimum(int A[], char B[], int n)
{
 
    // To store the minimum values
    // of 'a', 'b' and 'c'
    int minA = Integer.MAX_VALUE;
    int minB = Integer.MAX_VALUE;
    int minC = Integer.MAX_VALUE;
 
    // For every value of A[]
    for (int i = 0; i < n; i++)
    {
        switch (B[i])
        {
 
            // Update the minimum values of 'a',
            // 'b' and 'c'
            case 'a':
                minA = Math.min(A[i], minA);
                break;
                 
            case 'b':
                minB = Math.min(A[i], minB);
                break;
                 
            case 'c':
                minC = Math.min(A[i], minC);
                break;
        }
    }
 
    // Return the minimum required value
    return Math.min(minA + minB, minC);
}
 
// Driver code
public static void main(String[] args)
{
    int A[] = { 4, 2, 6, 2, 3 };
    char B[] = { 'b', 'a', 'c', 'a', 'b' };
 
    int n = A.length;
 
    System.out.println(getMinimum(A, B, n));
}
}
 
// This code is contributed by Rajput-Ji

# Python3 implementation of the approach
 
# Function to get the minimum required value
def getMinimum(A, B, n):
 
    # To store the minimum values
    # of 'a', 'b' and 'c'
    minA = float('inf');
    minB = float('inf');
    minC = float('inf');
 
    # For every value of A[]
    for i in range(n):
        if B[i]=='a':
            minA = min(A[i], minA)
        if B[i]=='b':
            minB = min(A[i], minB)
        if B[i]=='c':
            minB = min(A[i], minC)
 
    # Return the minimum required value
    return min(minA + minB, minC)
 
# Driver code
if __name__ == '__main__':
    A = [ 4, 2, 6, 2, 3 ]
    B = [ 'b', 'a', 'c', 'a', 'b' ]
    n = len(A);
 
    print(getMinimum(A, B, n))
 
# This code is contributed by Ashutosh450

// C# implementation of the above approach
using System;
 
class GFG
{
     
    // Function to get the minimum required value
    static int getMinimum(int []A, char []B, int n)
    {
     
        // To store the minimum values
        // of 'a', 'b' and 'c'
        int minA = int.MaxValue;
        int minB = int.MaxValue;
        int minC = int.MaxValue;
     
        // For every value of A[]
        for (int i = 0; i < n; i++)
        {
            switch (B[i])
            {
     
                // Update the minimum values of 'a',
                // 'b' and 'c'
                case 'a':
                    minA = Math.Min(A[i], minA);
                    break;
                     
                case 'b':
                    minB = Math.Min(A[i], minB);
                    break;
                     
                case 'c':
                    minC = Math.Min(A[i], minC);
                    break;
            }
        }
     
        // Return the minimum required value
        return Math.Min(minA + minB, minC);
    }
     
    // Driver code
    public static void Main()
    {
        int []A = { 4, 2, 6, 2, 3 };
        char []B = { 'b', 'a', 'c', 'a', 'b' };
     
        int n = A.Length;
     
        Console.WriteLine(getMinimum(A, B, n));
    }
}
 
// This code is contributed by AnkitRai01

<script>
 
 
// Javascript implementation of the approach
 
// Function to get the minimum required value
function getMinimum(A, B, n)
{
 
    // To store the minimum values
    // of 'a', 'b' and 'c'
    var minA = 1000000000;
    var minB = 1000000000;
    var minC = 1000000000;
 
    // For every value of A[]
    for (var i = 0; i < n; i++) {
        switch (B[i]) {
 
        // Update the minimum values of 'a',
        // 'b' and 'c'
        case 'a':
            minA = Math.min(A[i], minA);
            break;
        case 'b':
            minB = Math.min(A[i], minB);
            break;
        case 'c':
            minC = Math.min(A[i], minC);
            break;
        }
    }
 
    // Return the minimum required value
    return Math.min(minA + minB, minC);
}
 
// Driver code
var A = [4, 2, 6, 2, 3 ];
var B = ['b', 'a', 'c', 'a', 'b'];
var n = A.length;
document.write( getMinimum(A, B, n));
 
 
 
</script>

5