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

📅  最后修改于: 2021-04-24 04:30:22             🧑  作者: Mango

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

例子:

天真的方法:想法是生成三重整数的所有可能组合,整数的范围为[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


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 3 )
辅助空间: O(1)

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

  1. 迭代到N并生成两边可能的长度对,并使用关系x 2 + y 2 = z 2来找到第三边
  2. 如果发现sqrt(x 2 + y 2 )是一个整数,则将三个相关整数按排序顺序存储在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 2 )
辅助空间: O(1)