* Primera * Mayor aumento de Subsequence

Helsing:

La más larga subsecuencia creciente es el conocido problema y tengo una solución con el algoritmo de la paciencia.

El problema es que mi solución me da el "mejor secuencia más larga cada vez mayor" en lugar de la primera más larga sucesión creciente que aparece.

La diferencia es que algunos de los miembros de la secuencia son números más grandes en la primera (pero la longitud de la secuencia es exactamente el mismo).

Conseguir la primera secuencia está resultando ser bastante más difícil de lo esperado, ya que tener la mejor secuencia no se traduce fácilmente en tener la primera secuencia.

He pensado en hacer mi algoritmo de búsqueda a continuación, la primera secuencia de longitud N, pero no sabe cómo.

Así que, ¿cómo encontrar el primer larga aumentar subsecuencia de una secuencia de números enteros aleatorios?

Mi fragmento de código:

  public static void main (String[] args) throws java.lang.Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int inputInt;
        int[] intArr;

        try {
            String input = br.readLine().trim();
            inputInt = Integer.parseInt(input);
            String inputArr = br.readLine().trim();
            intArr = Arrays.stream(inputArr.split(" ")).mapToInt(Integer::parseInt).toArray();
        } catch (NumberFormatException e) {
            System.out.println("Could not parse integers.");
            return;
        }
        if(inputInt != intArr.length) {
            System.out.println("Invalid number of arguments.");
            return;
        }

        ArrayList<ArrayList<Integer>> sequences = new ArrayList<ArrayList<Integer>>();

        int sequenceCount = 1;
        sequences.add(new ArrayList<Integer>());
        sequences.get(0).add(0);

        for(int i = 1; i < intArr.length; i++) {
            for(int j = 0; j < sequenceCount; j++) {

                if(intArr[i] <= intArr[sequences.get(j).get(sequences.get(j).size() - 1)]) {
                    sequences.get(j).remove(sequences.get(j).size() - 1);
                    sequences.get(j).add(i);
                    break;
                } else if (j + 1 == sequenceCount) {
                    sequences.add(new ArrayList<Integer>(sequences.get(j)));
                    sequences.get(j + 1).add(i);
                    sequenceCount++;
                    break; //increasing sequenceCount causes infinite loop
                } else if(intArr[i] < intArr[sequences.get(j + 1).get(sequences.get(j + 1).size() - 1)]) {
                    sequences.set(j+ 1, new ArrayList<Integer>(sequences.get(j)));
                    sequences.get(j+ 1).add(i);
                    break;
                }
            }           
        }
        int bestSequenceLength = sequenceCount;
        ArrayList<Integer> bestIndexes = new ArrayList<Integer>(sequences.get(bestSequenceLength - 1));

        //build bestSequence, then after it I'm supposed to find the first one instead
        int[] bestSequence = Arrays.stream(bestIndexes.toArray()).mapToInt(x -> intArr[(int) x]).toArray();

       StringBuilder output = new StringBuilder("");
       for(Integer x : bestSequence) {
        output.append(x + " ");
       }
        System.out.println(output.toString().trim());
      }

Estoy almacenando índices lugar en preparación para tener que acceder a la matriz original de nuevo. Ya que es más fácil pasar de los índices a los valores que a la inversa.

Ejemplo:

3 6 1 2 8

Mi código devuelve: 1 2 8

Primera secuencia es: 3 6 8

Otro ejemplo:

1 5 2 3

Mi código devuelve correctamente: 1 2 3

Básicamente, mi código funciona siempre y cuando la primera secuencia más larga es la misma que la mejor secuencia más larga. Pero cuando se tiene un montón de secuencias más largas de la misma longitud, se agarra el mejor no el primero.

vivek_23:

Código es autoexplicativo. (Han añadido comentarios, que me haga saber si necesita algo extra).

public class Solution {
    public static void main(String[] args) {
        int[] arr = {3,6,1,2,8};
        System.out.println(solve(arr).toString());
    }

    private static List<Integer> solve(int[] arr){
        int[][] data = new int[arr.length][2];
        int max_length = 0;
        // first location for previous element index (for backtracing to print list) and second for longest series length for the element
        for(int i=0;i<arr.length;++i){
            data[i][0] = -1; //none should point to anything at first
            data[i][1] = 1;
            for(int j=i-1;j>=0;--j){
                if(arr[i] > arr[j]){
                    if(data[i][1] <= data[j][1] + 1){ // <= instead of < because we are aiming for the first longest sequence
                        data[i][1] = data[j][1] + 1;
                        data[i][0] = j;
                    }
                }
            }

            max_length = Math.max(max_length,data[i][1]);
        }

        List<Integer> ans = new ArrayList<>();

        for(int i=0;i<arr.length;++i){
            if(data[i][1] == max_length){
                int curr = i;
                while(curr != -1){
                    ans.add(arr[curr]);               
                    curr = data[curr][0];
                }                
                break;
            }
        }

        Collections.reverse(ans);// since there were added in reverse order in the above while loop
        return ans;
    }    
}

Salida:

[3, 6, 8]