计算边长不超过N的三角形数目

给定整数N ，任务是找到可以形成的直角三角形的总数，以使三角形任意边的长度最大为N。

A right-angled triangle satisfies the following condition: X² + Y² = Z² where Z represents the length of the hypotenuse, and X and Y represent the lengths of the remaining two sides. 

例子：

Input: N = 5 
Output: 1 
Explanation: 
The only possible combination of sides which form a right-angled triangle is {3, 4, 5}.

Input: N = 10 
Output: 2 
Explanation: 
Possible combinations of sides which form a right-angled triangle are {3, 4, 5} and {6, 8, 10}.

天真的方法：想法是生成三重整数的所有可能组合，整数的范围为[1，N] ，对于每个这样的组合，请检查它是否为直角三角形。

下面是上述方法的实现：

C++

// C++ implementation of
// the above approach
 
#include
using namespace std;
 
// Function to count total
// number of right angled triangle
int right_angled(int n)
{
    // Initialise count with 0
    int count = 0;
 
    // Run three nested loops and
    // check all combinations of sides
    for (int z = 1; z <= n; z++) {
        for (int y = 1; y <= z; y++) {
            for (int x = 1; x <= y; x++) {
 
                // Condition for right
                // angled triangle
                if ((x * x) + (y * y) == (z * z)) {
 
                    // Increment count
                    count++;
                }
            }
        }
    }
 
    return count;
}
 
// Driver Code
int main()
{
    // Given N
    int n = 5;
 
    // Function Call
    cout << right_angled(n);
    return 0;
}

Java

// Java implementation of 
// the above approach
import java.io.*;
 
class GFG{
     
// Function to count total
// number of right angled triangle
static int right_angled(int n)
{
     
    // Initialise count with 0
    int count = 0;
     
    // Run three nested loops and
    // check all combinations of sides
    for(int z = 1; z <= n; z++)
    {
        for(int y = 1; y <= z; y++)
        {
            for(int x = 1; x <= y; x++)
            {
                 
                // Condition for right
                // angled triangle
                if ((x * x) + (y * y) == (z * z))
                {
                     
                    // Increment count
                    count++;
                }
            }
        }
    }
    return count;
}
 
// Driver code
public static void main (String[] args)
{
     
    // Given N
    int n = 5;
 
    // Function call
    System.out.println(right_angled(n));
}
}
 
// This code is contributed by code_hunt

Python3

# Python implementation of 
# the above approach
 
# Function to count total
# number of right angled triangle
def right_angled(n):
     
    # Initialise count with 0
    count = 0
 
    # Run three nested loops and
    # check all combinations of sides
    for z in range(1, n + 1):
        for y in range(1, z + 1):
            for x in range(1, y + 1):
 
                # Condition for right
                # angled triangle
                if ((x * x) + (y * y) == (z * z)):
 
                    # Increment count
                    count += 1
                 
    return count
 
# Driver Code
 
# Given N
n = 5
 
# Function call
print(right_angled(n))
 
# This code is contributed by code_hunt

C#

// C# implementation of
// the above approach
using System;
 
class GFG{
     
// Function to count total
// number of right angled triangle
static int right_angled(int n)
{
     
    // Initialise count with 0
    int count = 0;
     
    // Run three nested loops and
    // check all combinations of sides
    for(int z = 1; z <= n; z++)
    {
        for(int y = 1; y <= z; y++)
        {
            for(int x = 1; x <= y; x++)
            {
                 
                // Condition for right
                // angled triangle
                if ((x * x) + (y * y) == (z * z))
                {
 
                    // Increment count
                    count++;
                }
            }
        }
    }
    return count;
}
     
// Driver Code
public static void Main(string[] args)
{
     
    // Given N
    int n = 5;
 
    // Function call
    Console.Write(right_angled(n));
}
}
 
// This code is contributed by rutvik_56

Javascript

// javascript implementation of 
// the above approach
    
// Function to count total
// number of right angled triangle
function right_angled(n)
{
     
    // Initialise count with 0
    var count = 0;
     
    // Run three nested loops and
    // check all combinations of sides
    for(z = 1; z <= n; z++)
    {
        for(y = 1; y <= z; y++)
        {
            for(x = 1; x <= y; x++)
            {
                 
                // Condition for right
                // angled triangle
                if ((x * x) + (y * y) == (z * z))
                {
                     
                    // Increment count
                    count++;
                }
            }
        }
    }
    return count;
}
 
// Driver code
//Given N
var n = 5;
 
// Function call
document.write(right_angled(n));
 
// This code is contributed by Amit Katiyar

输出：

1

时间复杂度： O(N ³ )
辅助空间： O(1)

高效的方法：如果已知三角形的两个边，则可以基于找到三角形的第三边的想法来优化上述方法。请按照以下步骤解决问题：

1. 迭代到N并生成两边可能的长度对，并使用关系x ² + y ² = z ²来找到第三边
2. 如果发现sqrt(x ² + y ² )是一个整数，则将三个相关整数按排序顺序存储在Set中，因为它们可以形成直角三角形。
3. 打印集的最终大小作为所需的计数。

下面是上述方法的实现：

C++

// C++ implementation of the
// above approach
#include 
using namespace std;
 
// Function to count total
// number of right angled triangle
int right_angled(int n)
{
    // Consider a set to store
    // the three sides
    set > > s;
 
    // Find possible third side
    for (int x = 1; x <= n; x++) {
        for (int y = 1; y <= n; y++) {
 
            // Condition for a right
            // angled triangle
            if (x * x + y * y <= n * n) {
                int z = sqrt(x * x + y * y);
 
                // Check if the third side
                // is an integer
                if (z * z != (x * x + y * y))
                    continue;
 
                vector v;
 
                // Push the three sides
                v.push_back(x);
                v.push_back(y);
                v.push_back(sqrt(x * x + y * y));
 
                sort(v.begin(), v.end());
 
                // Insert the three sides in
                // the set to find unique triangles
                s.insert({ v[0], { v[1], v[2] } });
            }
            else
                break;
        }
    }
 
    // return the size of set
    return s.size();
}
 
// Driver code
int main()
{
    // Given N
    int n = 5;
 
    // Function Call
    cout << right_angled(n);
    return 0;
}

Java

// Java implementation of the
// above approach
import java.util.*;
 
class Pair
{
     
    // First member of pair
    private F first;
     
    // Second member of pair
    private S second;
 
    public Pair(F first, S second)
    {
        this.first = first;
        this.second = second;
    }
}
 
class GFG{
 
// Function to count total
// number of right angled triangle    
public static int right_angled(int n)
{
     
    // Consider a set to store
    // the three sides
    Set>> s = new HashSet>>();
  
    // Find possible third side
    for(int x = 1; x <= n; x++)
    {
        for(int y = 1; y <= n; y++)
        {
             
            // Condition for a right
            // angled triangle
            if (x * x + y * y <= n * n)
            {
                int z = (int)Math.sqrt(x * x + y * y);
  
                // Check if the third side
                // is an integer
                if (z * z != (x * x + y * y))
                    continue;
  
                Vector v = new Vector();
                 
                // Push the three sides
                v.add(x);
                v.add(y);
                v.add((int)Math.sqrt(x * x + y * y));
  
                Collections.sort(v);
  
                // Add the three sides in
                // the set to find unique triangles
                s.add(new Pair>(v.get(0),
                      new Pair(v.get(1),
                                        v.get(2))));
            }
            else
                break;
        }
    }
     
    // Return the size of set
    return s.size() - 1;
}
  
// Driver code
public static void main(String[] args)
{
     
    // Given N
    int n = 5;
  
    // Function call
    System.out.println(right_angled(n));
}
}
 
// This code is contributed by grand_master

输出：

1

时间复杂度： O(N ² )
辅助空间： O(1)