Find maximum non contiguous subarray that respect a specific rule

Question

Given these two arrays:

[5, 3, 4, 1, 2]

[1, 3, 2, 4, 5]

Find the maximum subsequence in both arrays that the index of the elements are in a crescent order:

Example: [3, 4] it's an answer because the indexes are in a crescent way in both arrays. (same as [1, 2]). Therefore, the subsequence the answer [3, 4, 1] is wrong, because the indexes are the crescent in the first array, but not on the second one.

The output of the program should be the length of the max non-contiguous subarray.

This is the code I wrote for solving this, but it only takes the first subarray, and I'm having difficulty to generate the other possibilities

vector<pair<int, double>> esq;
vector<pair<int, double>> dir;
// N is the size of esq and dir
// pair<int, double> where int is the key (show in the example array) and double is the value, used for sort previously.
int cont = 1;
for (int i = 0; i < N - 1; i++)
{
    int cont_aux = 1;
    pair<int, double> pivot = esq[i];
    auto it_dir = find_if(dir.begin(), dir.end(), [&pivot](const pair<int, double> &p) { return p.first == pivot.first; });
    int last_index = it_dir - dir.begin();

    for (int j = 0; j < N; j++)
    {
        pair<int, double> actual = esq[j];
        auto it = find_if(dir.begin(), dir.end(), [&actual](const pair<int, double> &p) { return p.first == actual.first; });
        int pos = it - dir.begin();

        if (pos >= last_index) {
            last_index = pos;
            cont_aux++;
        }
    }

    cont = max(cont, cont_aux);
}

cout << cont << endl;

Stack Overflow is very code-focused, so "any language" is not something we can answer. If you want a theory-based solution, the [CS Site](http://cs.stackexchange.com) is a better fit. — tadman, Dec 08 '17 at 17:50
You absolutely could use C++. Take some time to **try** and create a solution, then edit your question with your attempt. This is not a free code writing service. You're going to have to show you're committed to solving the problem. — tadman, Dec 08 '17 at 17:52
This is a single part of a bigger problem that I'm solving from ICPC competition from this year. I'm really stuck at this part, tried for several hours and couldn't get a clue of how solve it. — Emanuel Huber, Dec 08 '17 at 17:56
If you've tried for several hours then you'd have something to show for your efforts. We'll gladly fix your broken, not quite working code. We won't create code for you from scratch. — tadman, Dec 08 '17 at 17:57
Ok, I will post my code. One more time, thanks for the advice :) — Emanuel Huber, Dec 08 '17 at 17:59

score 0 · Accepted Answer · answered Dec 09 '17 at 02:08

lista_test = [5,3, 4,1,7, 2]
lista2_test = [5,1,3, 2, 4,7]

def max_nocontigoous(list_a,list_b):
    #lets suppose that the list is ordered.
    count_i = 0
    count_j_previous = 0
    count_j = 0 
    counter_exclusive = 0
    listDouble = list()
    indice_real = 0
    for i in range(len(list_a)):
        try:
            element_a = list_a[i]
            if element_a in list_b and list_b.index(element_a)>=count_j:
                if count_j_previous != count_j:
                    listDouble[len(listDouble)-1].append(element_a)
                    count_j_previous = count_j
                else:
                    if(i == 0):
                        count_j_previous  -= 1
                    listDouble.append([element_a])
            else:
                listDouble.append([element_a])
                count_j_previous = count_j
                count_j = list_b.index(element_a)   
        except IndexError:
            print("Error in: " +str(i) + " iteration")
    return listDouble

print(max_nocontigoous(lista_test,lista2_test))

Notice that i have considered the first array or list in my case only can be a list whose values are in order and consecutively. I have just considered it because i have followed your example where you have an array with consecutively values ordered and the next array could be not necessarily consecutively. Good Look!

Find maximum non contiguous subarray that respect a specific rule

1 Answers1