Satisfacer la parábola cuando se da el punto (A, B) y la ecuación

Dado un punto (A, B) tal que la distancia desde cada punto de la curva My = Nx ² + Ox + P con (A, B) es igual a la distancia entre ese punto de la curva y el eje x . La tarea es encontrar el valor de M, NO y P. 

Nota: La ecuación debe estar en forma simple, es decir mcd( |M|, |N|, |O|, |P| ) = 1 y N siempre debe ser positivo.

Ejemplos:  

Entrada: A = 1, B = 1 
Salida: 2 1 -2 2 
M = 2, N = 1, O = -2, P = 2 
La ecuación de la curva será 
2y = x ² – 2x + 2

Entrada: A = -1, B = 1 
Salida: 2 1 2 2 

Aproximación: Por la propiedad de la parábola, para cada punto de la curva la distancia con la directriz y el foco siempre será igual. Usando esta propiedad, considere y = 0 como una directriz y (A, B) como el foco. 
Dado que en la ecuación N siempre es positivo, la parábola estará mirando hacia arriba y la ecuación de la parábola es (x – h) ² = 4p(y – k) donde (h, k) es la coordenada de el vértice y p es la distancia entre foco y vértice o vértice y directriz. 

Dado que el vértice es el punto medio entre la distancia perpendicular al foco (A, B) y la directriz aquí (A, 0) es B. Entonces la coordenada del vértice es (A, B/2) y p también es B/2 . 
Entonces, la ecuación será (x – A) ² = 4 * B/2 * (y – B/2) . 
Esta ecuación se puede resolver para obtener el resultado:

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 find the required values
void solve(int A, int B)
{
    double p = B / 2.0;
    int M = ceil(4 * p);
    int N = 1;
    int O = - 2 * A;
    int Q = ceil(A * A + 4 * p*p);
    cout << M << " " << N << " "
         << O << " " << Q;
}
 
// Driver code
int main()
{
    int a = 1;
    int b = 1;
    solve(a, b);
}
 
// This code is contributed by Mohit Kumar

// Java implementation of the approach
class GFG
{
     
    // Function to find the required values
    static void solve(int A, int B)
    {
        double p = B / 2.0;
        double M = Math.ceil(4 * p);
        int N = 1;
        int O = - 2 * A;
        double Q = Math.ceil(A * A + 4 * p * p);
        System.out.println(M + " " + N +
                               " " + O + " " + Q);
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int a = 1;
        int b = 1;
        solve(a, b);
    }
}
 
// This code is contributed by AnkitRai01

# Python3 implementation of the approach
 
# Function to find the required values
def solve(A, B):
    p = B / 2
    M = int(4 * p)
    N = 1
    O = - 2 * A
    Q = int(A * A + 4 * p*p)
    return [M, N, O, Q]
 
# Driver code
a = 1
b = 1
print(*solve(a, b))

// C# implementation of the approach
using System;
 
class GFG
{
    // Function to find the required values
    static void solve(int A, int B)
    {
        double p = B / 2.0;
         
        double M = Math.Ceiling(4 * p);
         
        int N = 1;
        int O = - 2 * A;
         
        double Q = Math.Ceiling(A * A + 4 * p * p);
         
        Console.Write(M + " " + N + " " + O + " " + Q);
    }
     
    // Driver code
    static public void Main ()
    {
        int a = 1;
        int b = 1;
        solve(a, b);
    }
}
 
// This code is contributed by AnkitRai01

<script>
 
    // JavaScript implementation of the approach
     
    // Function to find the required values
    function solve(A, B)
    {
        let p = B / 2.0;
        let M = Math.ceil(4 * p);
        let N = 1;
        let O = - 2 * A;
        let Q = Math.ceil(A * A + 4 * p * p);
        document.write(M + " " + N + " " + O + " " + Q);
    }
     
    let a = 1;
    let b = 1;
    solve(a, b);
     
</script>

2 1 -2 2

Complejidad de tiempo: O(1)

Espacio Auxiliar: O(1)