611. 有效三角形的个数

地址：

力扣https://leetcode-cn.com/problems/valid-triangle-number/

题目：

给定一个包含非负整数的数组，你的任务是统计其中可以组成三角形三条边的三元组个数。

示例 1:

输入: [2,2,3,4] 输出: 3 解释: 有效的组合是:  2,3,4 (使用第一个 2) 2,3,4 (使用第二个 2) 2,2,3

注意:

数组长度不超过1000。 数组里整数的范围为 [0, 1000]。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-triangle-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

又是三角形问题，自然跑不了排序和判定三角形(a+b>c)

穷举暴力法是最先能够想到的

不过用到了 3 次循环，看下示例 [2,2,3,4]

1. 第一个for ，下标 i 指向第一个元素

2. 第二个for，下标 j 指向 i+1 的元素

3. 第三个for，下标 k 指向 j+1 的元素

循环开始，i 不变，j不变，k移动直到不符合三角形的位置。这时此轮 j 完成

下一轮开始，j 移到下一位，k = j+1，继续；如此反复知道 j 循环完成，下一步就是移动 i

整个过程用到了 3 次嵌套，那么时间复杂度就是 O(n^3)，所以力扣里面测试用例过但超时

方法一、暴力穷举，时间复杂度 O(n^3)

int cmp(const int *p1, const int *p2)
{
    return (*(int*)p1) - (*(int *)p2);
}

int triangleNumber(int* nums, int numsSize){
    int i,j,k;
    int a,b,c;
    int cnt=0;
	
    if(numsSize <3)
        return 0;

    qsort(nums, numsSize, sizeof(int), cmp);

    for(i=0; i<numsSize-2; i++)
    {
        a=nums[i];

        for(j=i+1; j<numsSize-1; j++)
        {
            b=nums[j];
			
            for(k=j+1; k<numsSize; k++)
            {
                c=nums[k];

                if( (a+b) <= c)
                	break;
                cnt++;
            }
        }
    }

    return cnt;
}

因为一直超时，有没有思路，所以回头看英雄哥的解法

int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;
}

int triangleNumber(int* nums, int numsSize){
    int i, j, k;
    int ans = 0;
    qsort(nums, numsSize, sizeof(int), cmp);       // (1)
    for(i = 0; i < numsSize; ++i) {
        j = i + 1;
        k = j + 1;                                 // (2)
        while(j < numsSize) {
            while(k < numsSize) {
                if(nums[i] + nums[j] <= nums[k]) {
                    break;                         // (3)
                }
                ++k;               
            }
            ans += k-j-1;                          // (4)
            ++j;                                   // (5)
            if(k == j) k++;
        }
        
    }    
    return ans;
}

感觉有点像，但其实 k 的理解有不同。这里的 k 其实可以看作是符合三角形条件的边界下标

i+j>k 的最大处，所以 j~k 部分的个数就是符合条件的个数

注意，在下轮 j 循环时，新的循环并没有重新初始化 k 的位置，这样变相的节约了一次遍历

有可能 i+j 的边界还是上一次的 k，那么 j 依次循环移位直到与 k 相等，下一步就是要移动 i，肯定 k 的边界不能用了，所以 k 也顺势后移一位

也有可能 i+j 的边界大于 k ， 所以用少量的 k 循环再一次找到边界

有了这个 k 的新理解，我们可以改进超时的程序

int cmp(const int *p1, const int *p2)
{
	return (*(int*)p1) - (*(int*)p2);
}

int triangleNumber(int* nums, int numsSize){
    int i,j,k;
    int a,b,c;
    int cnt=0;
	
    if(numsSize <3)
        return 0;

    qsort(nums, numsSize, sizeof(int), cmp);

    for(i=0; i<numsSize-2; i++)
    {
        a=nums[i];
		j=i+1;
		k=j+1;
        //for(j=i+1; j<numsSize-1; j++)
		for(; j<numsSize-1; j++)
        {
            b=nums[j];
			
			if(j==k) k++;
            //for(k=j+1; k<numsSize; k++)
			for(; k<numsSize; k++)
            {
                c=nums[k];

                if( (a+b) <= c)
                	break;
                //cnt++;
            }
			
			cnt += k-j-1;
        }
    }

    return cnt;
}

结束语：

目前的水平暂时想到的只有暴力枚举

 查看更多刷题笔记