给定边范围内可能的三角形数量

给定四个整数A ， B ， C和D ，任务是找到不同集合(X，Y和Z)的数量，其中X，Y和Z表示形成有效三角形的边的长度。 A≤X≤B，B≤Y≤C和C≤Z≤D.
例子：

Input: A = 2, B = 3, C = 4, D = 5 
Output: 7 
Explanation: 
Possible Length of Side of Triangles are – 
{(2, 3, 4), (2, 4, 4), (2, 4, 5), (3, 3, 4), (3, 3, 5), (3, 4, 4) and (3, 4, 5)}
Input: A = 1, B = 1, C = 2, D = 2 
Output: 1 
Explanation: 
Only possible length of sides we can choose triangle is (1, 2, 2) 
 

天真的方法：问题中的主要观察结果是，如果X，Y和Z是三角形的有效边且X≤Y≤Z，则足以使这些边形成有效三角形的条件为X + Y> Z 。
最后，对于给定的X和Y，可能的Z值的计数可以计算为–

1. 如果X + Y大于D，在这种情况下，可以从[C，D]中选择Z，Z的总可能值为(D-C + 1)。
2. 如果X + Y小于D且大于C，则可以从[C，X + Y-1]中选择Z。
3. 如果X + Y小于或等于C，则我们不能选择Z，因为这些边将不会形成有效的三角形。

时间复杂度： $O(B * C)$

高效方法：想法是对A的所有可能值进行迭代，然后使用数学计算为给定的X计算可能的Y和Z值的数量。
对于给定的X，X + Y的值将在$[X+B, X+C]$ 。如果我们计算的可能值的数量大于D，则Y和Z的可能值的总数将为–

// Y和Z的可能值的数量// //如果num_greater是大于D的可能的Y值的数量$Possible values = num greater * (D - C + 1)$

同样，设R和L为C和D范围内X + Y值的上限和下界。那么，Y和Z的总组合为–

$Possible Values = \frac{R*(R+1)}{2} - \frac{L*(L+1)}{2}$

下面是上述方法的实现：

C++

// C++ implementation to count the
// number of possible triangles
// for the given sides ranges
 
#include 
using namespace std;
 
// Function to count the number of
// possible triangles for the given
// sides ranges
int count_triangles(int a, int b,
                    int c, int d)
{
 
    int ans = 0;
 
    // Iterate for every possible of x
    for (int x = a; x <= b; ++x) {
 
        // Range of y is [b, c]
        // From this range First
        // we will find the number
        // of x + y greater than d
        int num_greater_than_d = max(d, c + x) - max(d, b + x - 1);
 
        // For x+y greater than d
        // we can choose all z from [c, d]
        // Total permutation will be
        ans += num_greater_than_d * (d - c + 1);
 
        // Now we will find the number
        // of x+y in between the [c, d]
        int r = min(max(c, c + x), d) - c;
        int l = min(max(c, b + x - 1), d) - c;
 
        // [l, r] will be the range
        // from total [c, d] x+y belongs
        // For any r such that r = x+y
        // We can choose z, in the range
        // [c, d] only less than r,
        // Thus total permutation be
        int x1 = (r * (r + 1)) / 2;
        int x2 = (l * (l + 1)) / 2;
 
        ans += x1 - x2;
    }
 
    return ans;
}
 
// Driver Code
int main()
{
    int a = 2, b = 3, c = 4, d = 5;
 
    cout << count_triangles(a, b, c, d)
         << endl;
 
    return 0;
}

Java

// Java implementation to count the
// number of possible triangles
// for the given sides ranges
import java.util.Scanner;
import java.util.Arrays;
 
class GFG{
 
// Function to count the number of
// possible triangles for the given
// sides ranges
public static int count_triangles(int a, int b,
                                  int c, int d)
{
    int ans = 0;
 
    // Iterate for every possible of x
    for(int x = a; x <= b; ++x)
    {
 
        // Range of y is [b, c]
        // From this range First
        // we will find the number
        // of x + y greater than d
        int num_greater_than_d = Math.max(d, c + x) -
                                 Math.max(d, b + x - 1);
 
        // For x+y greater than d
        // we can choose all z from [c, d]
        // Total permutation will be
        ans += num_greater_than_d * (d - c + 1);
 
        // Now we will find the number
        // of x+y in between the [c, d]
        int r = Math.min(Math.max(c, c + x), d) - c;
        int l = Math.min(Math.max(c, b + x - 1), d) - c;
 
        // [l, r] will be the range
        // from total [c, d] x+y belongs
        // For any r such that r = x+y
        // We can choose z, in the range
        // [c, d] only less than r,
        // Thus total permutation be
        int x1 = (r * (r + 1)) / 2;
        int x2 = (l * (l + 1)) / 2;
 
        ans += x1 - x2;
    }
    return ans;
}
 
// Driver Code
public static void main(String args[])
{
    int a = 2, b = 3, c = 4, d = 5;
 
    System.out.println(count_triangles(a, b, c, d));
}
}
 
// This code is contributed by SoumikMondal

Python3

# Python3 implementation to count 
# the number of possible triangles
# for the given sides ranges
 
# Function to count the number of
# possible triangles for the given
# sides ranges
def count_triangles(a, b, c, d):
 
    ans = 0
 
    # Iterate for every possible of x
    for x in range(a, b + 1):
 
        # Range of y is [b, c]
        # From this range First
        # we will find the number
        # of x + y greater than d
        num_greater_than_d = (max(d, c + x) -
                              max(d, b + x - 1))
 
        # For x+y greater than d we
        # can choose all z from [c, d]
        # Total permutation will be
        ans = (ans + num_greater_than_d *
                             (d - c + 1))
 
        # Now we will find the number
        # of x+y in between the [c, d]
        r = min(max(c, c + x), d) - c;
        l = min(max(c, b + x - 1), d) - c;
 
        # [l, r] will be the range
        # from total [c, d] x+y belongs
        # For any r such that r = x+y
        # We can choose z, in the range
        # [c, d] only less than r,
        # Thus total permutation be
        x1 = int((r * (r + 1)) / 2)
        x2 = int((l * (l + 1)) / 2)
 
        ans = ans + (x1 - x2)
 
    return ans
 
# Driver Code
a = 2
b = 3
c = 4
d = 5
 
print (count_triangles(a, b, c, d), end = '\n')
 
# This code is contributed by PratikBasu

C#

// C# implementation to count the
// number of possible triangles
// for the given sides ranges
using System;
 
class GFG{
 
// Function to count the number of
// possible triangles for the given
// sides ranges
public static int count_triangles(int a, int b,
                                  int c, int d)
{
    int ans = 0;
 
    // Iterate for every possible of x
    for(int x = a; x <= b; ++x)
    {
 
        // Range of y is [b, c]
        // From this range First
        // we will find the number
        // of x + y greater than d
        int num_greater_than_d = Math.Max(d, c + x) -
                                 Math.Max(d, b + x - 1);
 
        // For x+y greater than d
        // we can choose all z from [c, d]
        // Total permutation will be
        ans += num_greater_than_d * (d - c + 1);
 
        // Now we will find the number
        // of x+y in between the [c, d]
        int r = Math.Min(Math.Max(c, c + x), d) - c;
        int l = Math.Min(Math.Max(c, b + x - 1), d) - c;
 
        // [l, r] will be the range
        // from total [c, d] x+y belongs
        // For any r such that r = x+y
        // We can choose z, in the range
        // [c, d] only less than r,
        // Thus total permutation be
        int x1 = (r * (r + 1)) / 2;
        int x2 = (l * (l + 1)) / 2;
 
        ans += x1 - x2;
    }
    return ans;
}
 
// Driver Code
public static void Main(String []args)
{
    int a = 2, b = 3, c = 4, d = 5;
 
    Console.WriteLine(count_triangles(a, b, c, d));
}
}
 
// This code is contributed by gauravrajput1

Javascript

 
// JavaScript implementation to count the
// number of possible triangles
// for the given sides ranges
 
// Function to count the number of
// possible triangles for the given
// sides ranges
function count_triangles(a , b, c , d)
{
    var ans = 0;
 
    // Iterate for every possible of x
    for(x = a; x <= b; ++x)
    {
 
        // Range of y is [b, c]
        // From this range First
        // we will find the number
        // of x + y greater than d
        var num_greater_than_d = Math.max(d, c + x) -
                                 Math.max(d, b + x - 1);
 
        // For x+y greater than d
        // we can choose all z from [c, d]
        // Total permutation will be
        ans += num_greater_than_d * (d - c + 1);
 
        // Now we will find the number
        // of x+y in between the [c, d]
        var r = Math.min(Math.max(c, c + x), d) - c;
        var l = Math.min(Math.max(c, b + x - 1), d) - c;
 
        // [l, r] will be the range
        // from total [c, d] x+y belongs
        // For any r such that r = x+y
        // We can choose z, in the range
        // [c, d] only less than r,
        // Thus total permutation be
        var x1 = (r * (r + 1)) / 2;
        var x2 = (l * (l + 1)) / 2;
 
        ans += x1 - x2;
    }
    return ans;
}
 
// Driver Code
 
var a = 2, b = 3, c = 4, d = 5;
 
document.write(count_triangles(a, b, c, d));
 
// This code contributed by shikhasingrajput
 

输出：

7