Visual C++ .NET - Ayuda problema C++

 
Vista:
sin imagen de perfil
Val: 1
Ha disminuido 1 puesto en Visual C++ .NET (en relación al último mes)
Gráfica de Visual C++ .NET

Ayuda problema C++

Publicado por Guillermo (1 intervención) el 27/10/2016 00:37:06
Hola, tengo que implementar un algoritmo que resuelva este problema:

P ≡ {0 < n < 10.000}
fun xxxx (int a[], int n) return int p
Q ≡ {(0 ≤ p < n) ∧ (menores(a, n, p) ∧ (¬∃j : 0 ≤ j < p : menores(a, n, j)}
donde menores(a, n, p) ≡ ∀u, w : 0 ≤ u ≤ p < w < n : a[u] < a[w]

Lo que te pide es hallar la posición P que cumple que todos los valores del vector hasta esa posición P son menores que el resto, y tiene que ser un algoritmo lineal, esto es lo que tengo pero no está bien

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int resolver(const vector<int> &v) {
	int maximoHastaP = v[0], p = 0;
	for (int i = 1; i < v.size() - 1; i++) {
		if (v[i] > maximoHastaP) {
			if (v[i + 1] <= v[p])
			maximoHastaP = v[i];
		}
		else if (v[i] <= maximoHastaP) {
			p = i;
			if (v[i + 1] <= maximoHastaP) p = i + 1;
		}
	}
	return p;
}

Por favor necesito ayuda
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Implementación de algoritmo lineal para encontrar posición P en vector

Publicado por Alejandro (265 intervenciones) el 14/02/2024 21:11:20
Guillermo, entiendo que estás tratando de encontrar la posición `P` tal que todos los valores en el vector hasta esa posición son menores que los valores después de esa posición. Tu implementación tiene algunos errores, y parece haber una confusión en la lógica del algoritmo.

Aquí tienes una versión corregida del algoritmo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <vector>
 
int resolver(const std::vector<int>& v) {
    int maximoHastaP = v[0], p = 0;
 
    for (int i = 1; i < v.size(); i++) {
        if (v[i] > maximoHastaP) {
            maximoHastaP = v[i];
            p = i;
        }
    }
 
    return p;
}

Explicación de los cambios:
1. Se ajustó el bucle para que incluya el último elemento del vector.
2. Se simplificó la lógica dentro del bucle. Ahora, si un elemento es mayor que el máximo hasta la posición `P`, actualizamos el máximo y la posición `P`. Esto garantiza que la posición `P` apunte al último elemento mayor encontrado.

Con estos cambios, el algoritmo debería cumplir con los requisitos de ser lineal y encontrar la posición `P` según la condición dada en la especificación.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar