Given an array of points on the X-Y plane points where points[i] = [xi, yi], return the area of the largest triangle that can be formed by any three different points. Answers within 10-5 of the actual answer will be accepted.

Input: points =[[0,0],[0,1],[1,0],[0,2],[2,0]]Output: 2.00000Explanation: The five points are shown in the above figure. The red triangle is the largest.
classSolution {
public:double largestTriangleArea(vector<vector<int>>& points) {
double ans =0;
int n = points.size();
for (int i =0; i < n; ++i)
for (int j = i+1; j < n; ++j)
for (int k = j+1; k < n; ++k) {
double area = abs(points[i][0]*(points[j][1]-points[k][1]) + points[j][0]*(points[k][1]-points[i][1]) + points[k][0]*(points[i][1]-points[j][1])) /2.0;
ans = max(ans, area);
}
return ans;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
funclargestTriangleArea(points [][]int) float64 {
ans:=0.0n:= len(points)
fori:=0; i < n; i++ {
forj:=i+1; j < n; j++ {
fork:=j+1; k < n; k++ {
area:=0.5*math.Abs(float64(points[i][0]*(points[j][1]-points[k][1]) +points[j][0]*(points[k][1]-points[i][1]) +points[k][0]*(points[i][1]-points[j][1])))
ifarea > ans { ans = area }
}
}
}
returnans}
1
2
3
4
5
6
7
8
9
10
11
12
13
classSolution {
publicdoublelargestTriangleArea(int[][] points) {
double ans = 0;
int n = points.length;
for (int i = 0; i < n; ++i)
for (int j = i+1; j < n; ++j)
for (int k = j+1; k < n; ++k) {
double area = Math.abs(points[i][0]*(points[j][1]-points[k][1]) + points[j][0]*(points[k][1]-points[i][1]) + points[k][0]*(points[i][1]-points[j][1])) / 2.0;
ans = Math.max(ans, area);
}
return ans;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
classSolution {
funlargestTriangleArea(points: Array<IntArray>): Double {
var ans = 0.0val n = points.size
for (i in0 until n)
for (j in i+1 until n)
for (k in j+1 until n) {
val area = Math.abs(points[i][0]*(points[j][1]-points[k][1]) + points[j][0]*(points[k][1]-points[i][1]) + points[k][0]*(points[i][1]-points[j][1])) / 2.0 ans = maxOf(ans, area)
}
return ans
}
}
1
2
3
4
5
6
7
8
classSolution:
deflargestTriangleArea(self, points: list[list[int]]) -> float:
from itertools import combinations
ans =0.0for a, b, c in combinations(points, 3):
area = abs(a[0]*(b[1]-c[1]) + b[0]*(c[1]-a[1]) + c[0]*(a[1]-b[1])) /2 ans = max(ans, area)
return ans
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
impl Solution {
pubfnlargest_triangle_area(points: Vec<Vec<i32>>) -> f64 {
letmut ans =0.0;
let n = points.len();
for i in0..n {
for j in i+1..n {
for k in j+1..n {
let area = ((points[i][0]*(points[j][1]-points[k][1]) + points[j][0]*(points[k][1]-points[i][1]) + points[k][0]*(points[i][1]-points[j][1])) asf64).abs() /2.0;
if area > ans { ans = area; }
}
}
}
ans
}
}