LeetCode-611. Valid Triangle Number

Description

Given an array consists of non-negative integers, your task is to count the number of triplets chosen 
from the array that can make triangles if we take them as side lengths of a triangle.

Example 1

Input: [2,2,3,4]
Output: 3
Explanation:
Valid combinations are: 
2,3,4 (using the first 2)
2,3,4 (using the second 2)
2,2,3

Note

1.The length of the given array won't exceed 1000.
2.The integers in the given array are in the range of [0, 100]

Solution 1(C++)

static int x=[](){std::ios::sync_with_stdio(false); cin.tie(NULL); return 0;}();
class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int ans=0, key, l, m, r, len=nums.size();
        for(int i=0; i<nums.size(); i++){
            for(int j=i+1; j<nums.size(); j++){
                key = nums[i]+nums[j];
                l=j+1;
                r=len-1;
                while(l<r){
                    m = l +(r+1-l>>1);
                    if(nums[m] < key) l=m;
                    else r=m-1;
                }
                if(nums[l]<key && l>j && l<len) ans+=(l-j);
            }
        }
        return ans;
    }
};

Solution 2(C++)

class Solution {
public:
    int triangleNumber(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int res = 0;
        for(int n = nums.size(), k = n - 1;  k >= 0; --k) {
            int i = 0;
            int j = k - 1;
            while(i < j) {
                if(nums[i] + nums[j] > nums[k]) {
                    res += j - i;
                    --j;
                }
                else {
                    ++i;
                }
            }
        }
        return res;
    }
};

Analysis of Algorithms

Solution 1 is written by myself. In fact, solution 1 and solution 2 have the same main idea, except that solution 1 searches after the double loop to satisfy that the sum of both sides is greater than the third side. One uses traversal and the other uses binary search. .

However, the running time of solution 1 is longer than that of solution 2, the reason should be that the loop of solution 1 has three layers. But binary search is still very important: Algorithm-Binary Search algorithm .

But looking back at the second solution, it is not unreasonable. can learn.

program analysis

slightly.