Número de ciclos formados al unir los vértices de un polígono de n lados en el centro

Dado un polígono regular de N lados , hemos conectado todos los vértices en el centro del polígono, dividiendo así el polígono en N partes iguales. Nuestra tarea es la Cuenta del número total de ciclos en el polígono.
Nota: un ciclo es un circuito cerrado que comienza y termina en el mismo punto.
Ejemplos: 
 

Entrada: N = 3 
Salida: 7 
Explicación: 
 

Cuando un polígono de 3 lados está conectado por vértices en el centro, tenemos 7 ciclos posibles para él, como se muestra en la imagen.
Entrada: N = 5 
Salida: 21 
Explicación: 
 

Cuando un polígono de 5 lados está conectado por vértices en el centro, tenemos 21 ciclos posibles para él, como se muestra en la imagen. 
 

Enfoque: Para el problema mencionado anteriormente, se supone que debemos contar el número total de bucles cerrados posibles en el polígono dado después de la división. El enfoque se basa en el patrón matemático . Habrá N ciclos ya creados debido a la división del polígono. Uno de N bloques formará un ciclo con el resto (N – 1) bloques. Los bloques restantes (N – 1) formarán un ciclo con otros (N – 2) bloques. Entonces, el total de ciclos que tenemos se puede encontrar usando la fórmula que se proporciona a continuación:
 

Ciclos totales = N + 1 * (N – 1) + (N – 1) * (N – 2) 
Ciclos totales = 2 * N – 1) + (N – 1) * (N – 2) 
 

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

// C++ program for the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to calculate number of cycles
int findCycles(int N)
{
    int res = 0;
    int finalResult = 0;
    int val = 2 * N - 1;
  
    // BigInteger is used here
    // if N=10^9 then multiply
    // will result into value
    // greater than 10^18
    int s = val;
  
    // BigInteger multiply function
    res = (N - 1) * (N - 2);
    finalResult = res + s;
  
    // Return the final result
    return finalResult;
}
 
// Driver code
int main()
{
    // Given N
    int N = 5;
  
    // Function Call
    cout << findCycles(N) << endl;   
    return 0;
}
 
// This code is contributed by divyeshrabadiya07

// Java program for the above approach
 
import java.util.*;
import java.math.*;
 
class GFG {
 
    // Function to calculate number of cycles
    static BigInteger findCycles(int N)
    {
        BigInteger res, finalResult;
        long val = 2 * N - 1;
 
        String st = String.valueOf(val);
 
        // BigInteger is used here
        // if N=10^9 then multiply
        // will result into value
        // greater than 10^18
 
        BigInteger str = new BigInteger(st);
        String n1 = String.valueOf((N - 1));
        String n2 = String.valueOf((N - 2));
 
        BigInteger a = new BigInteger(n1);
        BigInteger b = new BigInteger(n2);
 
        // BigInteger multiply function
        res = a.multiply(b);
 
        finalResult = res.add(str);
 
        // Return the final result
        return finalResult;
    }
 
    // Driver Code
    public static void
    main(String args[]) throws Exception
    {
        // Given N
        int N = 5;
 
        // Function Call
        System.out.println(findCycles(N));
    }
}

# Python3 program for the above approach
  
# Function to calculate number of cycles
def findCycles(N):
    res = 0
    finalResult = 0
    val = 2 * N - 1;
 
    # BigInteger is used here
    # if N=10^9 then multiply
    # will result into value
    # greater than 10^18
    s = val
 
    # BigInteger multiply function
    res = (N - 1) * (N - 2)
    finalResult = res + s;
 
    # Return the final result
    return finalResult;
 
# Driver Code
if __name__=='__main__':
     
    # Given N
    N = 5;
 
    # Function Call
    print(findCycles(N));
 
    # This code is contributed by pratham76

// C# program for the above approach
using System;
class GFG {
 
  // Function to calculate number of cycles
  static int findCycles(int N)
  {
    int res = 0;
    int finalResult = 0;
    int val = 2 * N - 1;
 
    // BigInteger is used here
    // if N=10^9 then multiply
    // will result into value
    // greater than 10^18
    int s = val;
 
    // BigInteger multiply function
    res = (N - 1) * (N - 2);
    finalResult = res + s;
 
    // Return the final result
    return finalResult;
  }
 
  // Driver code
  static void Main()
  {
     
    // Given N
    int N = 5;
 
    // Function Call
    Console.WriteLine(findCycles(N));
  }
}
 
// This code is contributed by divyesh072019

<script>
 
    // Javascript program for the above approach
     
    // Function to calculate number of cycles
    function findCycles(N)
    {
      let res = 0;
      let finalResult = 0;
      let val = 2 * N - 1;
 
      // BigInteger is used here
      // if N=10^9 then multiply
      // will result into value
      // greater than 10^18
      let s = val;
 
      // BigInteger multiply function
      res = (N - 1) * (N - 2);
      finalResult = res + s;
 
      // Return the final result
      return finalResult;
    }
     
    // Given N
    let N = 5;
  
    // Function Call
    document.write(findCycles(N));
     
</script>

21

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)