Método de factorización de Fermat para números grandes

Dado un gran número N , la tarea es dividir este número en un producto de dos factores, utilizando el método de Factorización de Fermat .

Ejemplos

Entrada: N = 105327569
Salida: 10223, 10303

Entrada: N = 249803
Salida: 23, 10861

Factorización de Fermat : el método de factorización de Fermat se basa en la representación de un número entero impar como la diferencia de dos cuadrados.
Para un número entero N, queremos a y b como:

N = a² - b² = (a+b)(a-b) 

where (a+b) and (a-b) are 
the factors of the number N.

Acercarse:

Obtenga el número como un objeto de la clase BigInteger
Encuentre la raíz cuadrada de N .
Se garantiza que el valor de a es mayor que sqrt(N) y el valor de b es menor que sqrt(N).
Tome el valor de sqrt(n) como a e incremente el número hasta que y a menos que se encuentre un número b tal que N – a^2 sea un cuadrado perfecto.

A continuación se muestra la implementación del enfoque anterior:

// Java program for Fermat's Factorization
// method for large numbers
  
import java.math.*;
import java.util.*;
  
class Solution {
  
    // Function to find the Floor
    // of square root of a number
    public static BigInteger sqrtF(BigInteger x)
        throws IllegalArgumentException
    {
        // if x is less than 0
        if (x.compareTo(BigInteger.ZERO) < 0) {
            throw new IllegalArgumentException(
                "Negative argument.");
        }
  
        // if x==0 or x==1
        if (x.equals(BigInteger.ZERO)
            || x.equals(BigInteger.ONE)) {
            return x;
        }
  
        BigInteger two
            = BigInteger.valueOf(2L);
        BigInteger y;
  
        // run a loop
        y = x.divide(two);
        while (y.compareTo(x.divide(y)) > 0)
            y = ((x.divide(y)).add(y))
                    .divide(two);
        return y;
    }
  
    // function to find the Ceil
    // of square root of a number
    public static BigInteger sqrtC(BigInteger x)
        throws IllegalArgumentException
    {
        BigInteger y = sqrtF(x);
  
        if (x.compareTo(y.multiply(y)) == 0) {
            return y;
        }
  
        else {
            return y.add(BigInteger.ONE);
        }
    }
  
    // Fermat factorisation
    static String FermatFactors(BigInteger n)
    {
        // constants
        BigInteger ONE = new BigInteger("1");
        BigInteger ZERO = new BigInteger("0");
        BigInteger TWO = new BigInteger("2");
  
        // if n%2 ==0 then return the factors
        if (n.mod(TWO).equals(ZERO)) {
            return n.divide(TWO)
                       .toString()
                + ", 2";
        }
  
        // find the square root
        BigInteger a = sqrtC(n);
  
        // if the number is a perfect square
        if (a.multiply(a).equals(n)) {
            return a.toString()
                + ", " + a.toString();
        }
  
        // else perform factorisation
        BigInteger b;
        while (true) {
            BigInteger b1 = a.multiply(a)
                                .subtract(n);
            b = sqrtF(b1);
  
            if (b.multiply(b).equals(b1))
                break;
            else
                a = a.add(ONE);
        }
  
        return a.subtract(b).toString()
            + ", " + a.add(b).toString();
    }
  
    // Driver code
    public static void main(String args[])
    {
        String N = "105327569";
  
        System.out.println(
            FermatFactors(
                new BigInteger(N)));
    }
}

Producción:

10223, 10303

Análisis de rendimiento:

Complejidad del tiempo: O(sqrt(N))
Complejidad espacial: O(1)

Publicación traducida automáticamente

Artículo escrito por andrew1234 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta