非交叉线连接圆中的点

考虑一个在圆周上有n个点的圆，其中n是偶数。计算我们连接这些点的方式的数目，这样就不会有两条连接线互相交叉，并且每个点都恰好与另一个点连接。任何一点都可以与任何其他点连接。

Consider a circle with 4 points.
    1
2        3
    4
In above diagram, there are two 
non-crossing ways to connect
{{1, 2}, {3, 4}} and {{1, 3}, {2, 4}}.

Note that {{2, 3}, {1, 4}} is invalid
as it would cause a cross

例子 ：

Input : n = 2
Output : 1

Input : n = 4
Output : 2

Input : n = 6
Output : 5

Input : n = 3
Output : Invalid
n must be even.

我们需要画n / 2条线来连接n个点。画一条线时，我们将点分为需要连接的两组。每个集合都需要在自身内部进行连接。以下是相同的重复关系。

Let m = n/2

// For each line we draw, we divide points
// into two sets such that one set is going
// to be connected with i lines and other
// with m-i-1 lines.
Count(m) = ∑ Count(i) * Count(m-i-1) 
           where 0 <= i < m
Count(0) = 1

Total number of ways with n points 
               = Count(m) = Count(n/2)

如果我们仔细研究以上重复，则实际上是加泰罗尼亚数的重复。因此，任务减少为找到第n / 2个加泰罗尼亚数字。
下面是基于以上思想的实现。

C++

// C++ program to count number of ways to connect n (where n
// is even) points on a circle such that no two connecting
// lines cross each other and every point is connected with
// one other point.
#include
using namespace std;
 
// A dynamic programming based function to find nth
// Catalan number
unsigned long int catalanDP(unsigned int n)
{
    // Table to store results of subproblems
    unsigned long int catalan[n+1];
 
    // Initialize first two values in table
    catalan[0] = catalan[1] = 1;
 
    // Fill entries in catalan[] using recursive formula
    for (int i=2; i<=n; i++)
    {
        catalan[i] = 0;
        for (int j=0; j

---

Java

// Java program to count number
// of ways to connect n (where
// n is even) points on a circle
// such that no two connecting
// lines cross each other and
// every point is connected with
// one other point.
import java.io.*;
 
class GFG
{
 
// A dynamic programming
// based function to find
// nth Catalan number
static int catalanDP(int n)
{
    // Table to store
    // results of subproblems
    int []catalan = new int [n + 1];
 
    // Initialize first
    // two values in table
    catalan[0] = catalan[1] = 1;
 
    // Fill entries in catalan[]
    // using recursive formula
    for (int i = 2; i <= n; i++)
    {
        catalan[i] = 0;
        for (int j = 0; j < i; j++)
            catalan[i] += catalan[j] *
                          catalan[i - j - 1];
    }
 
    // Return last entry
    return catalan[n];
}
 
// Returns count of ways to
// connect n points on a circle
// such that no two connecting
// lines cross each other and
// every point is connected
// with one other point.
static int countWays(int n)
{
    // Throw error if n is odd
    if (n < 1)
    {
        System.out.println("Invalid");
        return 0;
    }
 
    // Else return n/2'th
    // Catalan number
    return catalanDP(n / 2);
}
 
// Driver Code
public static void main (String[] args)
{
    System.out.println(countWays(6) + " ");
}
}
 
// This code is contributed
// by akt_mit

Python3

# Python3 program to count number
# of ways to connect n (where n
# is even) points on a circle such
# that no two connecting lines
# cross each other and every point
# is connected with one other point.
 
# A dynamic programming based
# function to find nth Catalan number
def catalanDP(n):
     
    # Table to store results
    # of subproblems
    catalan = [1 for i in range(n + 1)]
     
    # Fill entries in catalan[]
    # using recursive formula
    for i in range(2, n + 1):
        catalan[i] = 0
        for j in range(i):
            catalan[i] += (catalan[j] *
                           catalan[i - j - 1])
    # Return last entry
    return catalan[n]
 
# Returns count of ways to connect
# n points on a circle such that
# no two connecting lines cross
# each other and every point is
# connected with one other point.
def countWays(n):
     
    # Throw error if n is odd
    if (n & 1):
        print("Invalid")
        return 0
         
    # Else return n/2'th Catalan number
    return catalanDP(n // 2)
 
# Driver Code
print(countWays(6))
 
# This code is contributed
# by sahilshelangia

C#

// C# program to count number
// of ways to connect n (where
// n is even) points on a circle
// such that no two connecting
// lines cross each other and
// every point is connected with
// one other point.
using System;
 
class GFG
{
     
// A dynamic programming
// based function to find
// nth Catalan number
static int catalanDP(int n)
{
    // Table to store
    // results of subproblems
    int []catalan = new int [n + 1];
 
    // Initialize first
    // two values in table
    catalan[0] = catalan[1] = 1;
 
    // Fill entries in catalan[]
    // using recursive formula
    for (int i = 2; i <= n; i++)
    {
        catalan[i] = 0;
        for (int j = 0; j < i; j++)
            catalan[i] += catalan[j] *
                          catalan[i - j - 1];
    }
 
    // Return last entry
    return catalan[n];
}
 
// Returns count of ways to
// connect n points on a circle
// such that no two connecting
// lines cross each other and
// every point is connected
// with one other point.
static int countWays(int n)
{
    // Throw error if n is odd
    if (n < 1)
    {
        Console.WriteLine("Invalid");
        return 0;
    }
 
    // Else return n/2'th
    // Catalan number
    return catalanDP(n / 2);
}
 
// Driver Code
static public void Main ()
{
    Console.WriteLine(countWays(6) + " ");
}
}
 
// This code is contributed
// by M_kit

Javascript

// javascript program to count number of
// ways to connect n (where n is
// even) points on a circle such
// that no two connecting lines
// cross each other and every
// point is connected with one
// other point.
 
// A dynamic programming based
// function to find nth Catalan number
function catalanDP(n)
{
    // Table to store results
    // of subproblems Initialize
    // first two values in table
    let catalan = []
    catalan[0] = catalan[1] = 1;
 
    // Fill entries in catalan[]
    // using recursive formula
    for (let i = 2; i <= n; i++)
    {
        catalan[i] = 0;
        for (let j = 0; j < i; j++)
            catalan[i] += catalan[j] *
                            catalan[i - j - 1];
    }
 
    // Return last entry
    return catalan[n];
}
 
// Returns count of ways to connect
// n points on a circle such that
// no two connecting lines cross
// each other and every point is
// connected with one other point.
function countWays(n)
{
// Throw error if n is odd
if (n & 1)
{
    document.write("Invalid");
    return 0;
}
 
// Else return n/2'th
// Catalan number
return catalanDP(n / 2);
}
 
// Driver Code
document.write(countWays(6) + " ");
 
// This code is contributed by _saurabh_jaiswal

输出 ：

5