三和的范围内的总和（1,2）
在数组中给出
n个正实数，找出是否存在三元组 在这个集合中，三元组的总和在(1, 2)的范围内。在线性时间和恒定空间中进行。
- 数组未订购。
- 数字为正
- 数字实数
非常感谢任何帮助。感谢。
9 个答案:
答案 0 :(得分：30)
诀窍是找出一种方法来对可能的解决方案进行分类，并为每种解决方案提出线性时间恒定空间解决方案。
考虑三个范围X = (0,2/3), Y = [2/3,1], Z = (1,2)。最多一个值可以来自Z（如果两个值来自Z，则总和将超过1+1=2）。同样，至少有一个值必须来自X。假设有3个值a <= b <= c，那么1 <= a+b+c <= 2。然后，考虑哪些可能的解决方案是可行的：
A) `a \in X, b \in X, C \in X`
B) `a \in X, b \in X, C \in Y`
C) `a \in X, b \in X, C \in Z`
D) `a \in X, b \in Y, C \in Y`
E) `a \in X, b \in Y, C \in Z`
那么我们如何测试每个案例？
案例A非常容易测试：总和保证低于2，所以我们只需要测试最大的总和（X中最大的3个元素）超过1。
案例C非常容易测试：因为总和保证在1以上，我们只需要检查总和是否低于2.所以为了做到这一点，我们只需要测试最小的2个值X和Z中的最小值
案例D和E类似于C（因为总和必须至少为4/3> 1，请在每个类中选择最小的可能值。）
案例B是唯一棘手的案例。 0 < a+b < 4/3和2/3 <= c <= 1。为了处理案例B，我们考虑这些区间：X1 =（0,1 / 2），X2 = [1/2 2/3），Y = [2 / 3,1]。
这导致以下三个有效案例：
B1。 a中的a，x2中的b，y中的c
B2。 a中的a，X1中的b，y中的c
B3。 a在X2中，b在X2中，c在Y中
案例B1＆amp; B3：三个数字之和总是大于1，所以我们取最小值并检查它是否小于2。
案例B2：三个数字之和总是小于2，所以我们取最大值并检查是否大于1。
总而言之，测试是：
-
|X| >= 3和Xmax(1) + Xmax(2) + Xmax(3) >= 1 -
|X| >= 2，|Z| >= 1和Xmin(1)+Xmin(2)+Zmin(1) <= 2 -
|X| >= 1，|Y| >= 2和Xmin(1)+Ymin(1)+Ymin(2) <= 2 -
|X| >= 1，|Y| >= 1，|Z| >= 1和Xmin(1)+Ymin(1)+Zmin(1) <= 2 -
|X| >= 2，|Y| >= 1和Xmax(1) + Xmax(2) + Ymin(1) < 2 -
|X| >= 2，|Y| >= 1和Xmin(1) + Xmin(2) + Ymax(1) > 1）
每个测试都可以在线性时间和恒定空间中执行（您只需找到Xmax(1), Xmax(2), Xmax(3), Xmin(1), Xmin(2), Ymin(1), Ymin(2), Ymax(1), Zmin(1)，即使数据未排序，所有这些都可以在一次通过中找到）
答案 1 :(得分：2)
询问的问题与this InterviewBit 问题类似。我对下面提到的解决方案进行了一些更改，以完全符合您的要求。
有三个条件：
- 首先，如果总和在1到2之间。
- 第二，如果总和大于2，则三个元素中的较大元素将替换为下一个元素，并重复该过程。
- 第三，如果总和小于1，则将三个元素中较小的一个替换为下一个元素，并重复相同的过程。
int Solution::solve(vector<float> &A) {
if(A.size()<3) return 0;
float a = A[0];
float b = A[1];
float c = A[2];
for(int i=3;i<A.size();++i){
if(a+b+c>1 && a+b+c<2)
return 1;
float temp = A[i];
if(a+b+c>=2){
if(a>b && a>c)
a = temp;
else if(b>c && b>a)
b = temp;
else
c = temp;
}
else{
if(a<b && a<c)
a = temp;
else if(b<c && b<a)
b = temp;
else
c = temp;
}
}
if(a+b+c>1 && a+b+c<2) return 1;
return 0;
}
使用两个指针技术也可以解决相同的问题。首先，我们必须对数组进行排序。但是，它的复杂性将超过O（logn）。
int Solution::solve(vector<float> &A) {
int n = A.size();
if(n<3) return 0;
sort(A.begin(), A.end());
int l = 0, r = n-1;
while(l<r-1){
float s = A[l]+A[l+1]+A[r];
if(s>=2)
r = r-1;
else if(s<1)
l = l+1;
else return 1;
}
return 0;
}
答案 2 :(得分：0)
因此，您有一个长度为n的双数据类型数组。初始化三个变量a，b和c作为array的前3个值。现在，从i = 3迭代到n并检查以下内容：1）检查sum是否落入（1,2），如果确实则返回true。 2）如果不是，则检查sum是否大于2，如果是，则将MAX（a，b，c）替换为当前元素arr [i]。 3）否则总和必须小于1然后将MIN（a，b，c）替换为当前元素arr [i]。最后在循环结束后再次检查最后三元组，如果总和落入（1,2）那么返回true，否则返回false。
enter code here
double a=arr[0], b=arr[1], c=arr[2];
for(int i=3 ; i<n ; i++){
// check if sum fall in (1, 2)
if(a+b+c > 1 && a+b+c < 2){
return 1;
}
// if not, then check is sum greater than 2
// if so, then replece MAX(a,b,c) to new number
else if(a+b+c > 2){
if(a>b && a>c){
a = arr[i];
}
else if(b>a && b>c){
b = arr[i];
}
else if(c>a && c>b){
c = arr[i];
}
}
// else then sum must be less than 1
// then replace MIN(a,b,c) to new number
else{
if(a<b && a<c){
a = arr[i];
}
else if(b<a && b<c){
b = arr[i];
}
else if(c<a && c<b){
c = arr[i];
}
}
}
// check for last a, b, c triplet
if(a+b+c > 1 && a+b+c < 2){
return 1;
}
else{
return 0;
}
答案 3 :(得分：0)
基于@Soul Ec的想法，这是我想到的代码。效果很好。
vector<double> x;
vector<double> y;
vector<double> z;
double d = (double)2/3;
for(i = 0 ; i < arr.size() ; i++){
if(arr[i] >= 0 && arr[i] < d) x.push_back(arr[i]);
else if(arr[i] >= d && arr[i] <= 1) y.push_back(arr[i]);
else z.push_back(arr[i]);
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
sort(z.begin(), z.end());
int xsz = x.size();
int ysz = y.size();
int zsz = z.size();
if(xsz >= 3 && x[xsz-1] + x[xsz-2] + x[xsz-3] >= 1.0) return 1;
if(xsz >= 2 && zsz >= 1 && x[0] + x[1] + z[0] <= 2.0) return 1;
if(xsz >= 1 && ysz >= 2 && x[0] + y[0] + y[1] <= (double)2.0) return 1;
if(xsz >= 1 && ysz >= 1 && zsz >= 1 && x[0] + y[0] + z[0] <= 2.0) return 1;
if(xsz >= 2 && ysz >= 1){
if(x[xsz-1] + x[xsz-2] + y[0] < 2.0 && x[xsz-1] + x[xsz-2] + y[0] > 1.0) return 1;
if(x[0] + x[1] + y[ysz-1] > 1.0 && x[0] + x[1] + y[ysz-1] < 2.0) return 1;
}
答案 4 :(得分：0)
@soul Ec给出的解决方案的Java代码。
我们需要修改案例B。 假设我们的数字是a + b + c
there are three ranges
x1 x2 y
(0,1/2) (1/2,2/3) (2/3,1)
we have 4 possibilities
1. x1 + x1 +y
2. x2 + x2 +y
3. x1 + x2 +y
4 x2 + x1 +y
在此情况3和4相同，因为它们的总和相同。所以我们只有3种情况。
1. x1 + x1 + y it is always <2 ( do x1max+x1max+ymax <2 to verify)
so we have to check if x1max(1)+x1max(2)+ymax(1) > 1
2. x2 + x2 + y it is always >1 ( do x2min+x2min+ymin >1 to verify)
so we have to check if x2min(1)+x2min(2)+ymin(1) <=2
3. x1 + x2 + y it is always >1 (do x1min+x2min+ymin >1 to verify)
so we have to check if x1min(1)+x2min(1)+ymin(1)<=2
public static int solve(ArrayList<String> A) {
double d[]= new double[A.size()];
for(int i=0;i<A.size();i++) {
d[i]= Double.parseDouble(A.get(i));
}
double range1 = 0;
double range2 = (double) 2/3;
double range3 = 1;
double range4 = 2;
double range02 =(double) 1/2;
// min and max in range (0,2/3)
double min1= Double.MAX_VALUE;
double min2=Double.MAX_VALUE;
double min3=Double.MAX_VALUE;
double max1= Double.MIN_VALUE;
double max2=Double.MIN_VALUE;
double max3=Double.MIN_VALUE;
// min and max in range (2/3,1)
double miny1= Double.MAX_VALUE;
double miny2=Double.MAX_VALUE;
double miny3=Double.MAX_VALUE;
double maxy1= Double.MIN_VALUE;
double maxy2=Double.MIN_VALUE;
double maxy3=Double.MIN_VALUE;
// min and max in range (1,2)
double minz1= Double.MAX_VALUE;
double minz2=Double.MAX_VALUE;
double minz3=Double.MAX_VALUE;
double maxz1= Double.MIN_VALUE;
double maxz2=Double.MIN_VALUE;
double maxz3=Double.MIN_VALUE;
// min and max in range (0,1/2)
double minxx1= Double.MAX_VALUE;
double minxx2=Double.MAX_VALUE;
double minxx3=Double.MAX_VALUE;
double maxx1= Double.MIN_VALUE;
double maxx2=Double.MIN_VALUE;
double maxx3=Double.MIN_VALUE;
// min and max in range (1/2,2/3)
double minyy1= Double.MAX_VALUE;
double minyy2=Double.MAX_VALUE;
double minyy3=Double.MAX_VALUE;
double maxyy1= Double.MIN_VALUE;
double maxyy2=Double.MIN_VALUE;
double maxyy3=Double.MIN_VALUE;
for (int i = 0; i < d.length; i++) {
if (d[i] >= range1 && d[i] < range02) {
if (d[i] < minxx3) {
minxx1=minxx2;
minxx2=minxx3;
minxx3 = d[i];
} else if (d[i] > minxx3 && d[i] < minxx2) {
minxx1=minxx2;
minxx2 = d[i];
} else if (d[i] > minxx3 && d[i] > minxx2 && d[i] < minxx1) {
minxx1 = d[i];
}
if (d[i] > maxx3) {
maxx1=maxx2;
maxx2=maxx3;
maxx3 = d[i];
} else if (d[i] < maxx3 && d[i] > maxx2) {
maxx1=maxx2;
maxx2 = d[i];
} else if (d[i] < maxx3 && d[i] < maxx2 && d[i] > maxx1) {
maxx1 = d[i];
}
}
if (d[i] >= range02 && d[i] < range2) {
if (d[i] < minyy3) {
minyy1=minyy2;
minyy2=minyy3;
minyy3 = d[i];
} else if (d[i] > minyy3 && d[i] < minyy2) {
minyy1=minyy2;
minyy2 = d[i];
} else if (d[i] > minyy3 && d[i] > minyy2 && d[i] < minyy1) {
minyy1 = d[i];
}
if (d[i] > maxyy3) {
maxyy1=maxyy2;
maxyy2=maxyy3;
maxyy3 = d[i];
} else if (d[i] < maxyy3 && d[i] > maxyy2) {
maxyy1=maxyy2;
maxyy2 = d[i];
} else if (d[i] < maxyy3 && d[i] < maxyy2 && d[i] > maxyy1) {
maxyy1 = d[i];
}
}
if (d[i] >= range1 && d[i] < range2) {
if (d[i] < min3) {
min1=min2;
min2=min3;
min3 = d[i];
} else if (d[i] > min3 && d[i] < min2) {
min1=min2;
min2 = d[i];
} else if (d[i] > min3 && d[i] > min2 && d[i] < min1) {
min1 = d[i];
}
if (d[i] > max3) {
max1=max2;
max2=max3;
max3 = d[i];
} else if (d[i] < max3 && d[i] > max2) {
max1=max2;
max2 = d[i];
} else if (d[i] < max3 && d[i] < max2 && d[i] > max1) {
max1 = d[i];
}
}
if (d[i] >= range2 && d[i] < range3) {
if (d[i] < miny3) {
miny1=miny2;
miny2=miny3;
miny3 = d[i];
} else if (d[i] > miny3 && d[i] < miny2) {
miny1=miny2;
miny2 = d[i];
} else if (d[i] > miny3 && d[i] > miny2 && d[i] < miny1) {
miny1 = d[i];
}
if (d[i] > maxy3) {
maxy1=maxy2;
maxy2=maxy3;
maxy3 = d[i];
} else if (d[i] < maxy3 && d[i] > maxy2) {
maxy1=maxy2;
maxy2 = d[i];
} else if (d[i] < maxy3 && d[i] < maxy2 && d[i] > maxy1) {
maxy1 = d[i];
}
}
if (d[i] >= range3 && d[i] <= range4) {
if (d[i] < minz3) {
minz1=minz2;
minz2=minz3;
minz3 = d[i];
} else if (d[i] > minz3 && d[i] < minz2) {
minz1=minz2;
minz2 = d[i];
} else if (d[i] > minz3 && d[i] > minz2 && d[i] < minz1) {
minz1 = d[i];
}
if (d[i] > maxz3) {
maxz1=maxz2;
maxz2=maxz3;
maxz3 = d[i];
} else if (d[i] < maxz3 && d[i] > maxz2) {
maxz1=maxz2;
maxz2 = d[i];
} else if (d[i] < maxz3 && d[i] < maxz2 && d[i] > maxz1) {
maxz1 = d[i];
}
}
}
if(max1+max2+max3>=1 && max1!=Double.MIN_VALUE && max2!=Double.MIN_VALUE && max3!=Double.MIN_VALUE)
return 1;
if(min3+min2+minz3<=2 && min3!=Double.MAX_VALUE && min2!=Double.MAX_VALUE && minz3!=Double.MAX_VALUE )
return 1;
if(min3+miny3+miny2<=2 && min3!=Double.MAX_VALUE && miny3!=Double.MAX_VALUE && miny2!=Double.MAX_VALUE)
return 1;
if(min3+miny3+minz3<=2 && min3!=Double.MAX_VALUE && miny3!=Double.MAX_VALUE && minz3!=Double.MAX_VALUE)
return 1;
if(maxx3+maxx2+maxy3>1 && maxx3!=Double.MIN_VALUE && maxx2!=Double.MIN_VALUE && maxy3!=Double.MIN_VALUE) {
return 1;
}
if(minyy3+minyy2+miny3<=2 && minyy3!=Double.MAX_VALUE && minyy2!=Double.MAX_VALUE && miny3!=Double.MAX_VALUE) {
return 1;
}
if(minxx3+minyy3+miny3<=2 && minxx3!=Double.MAX_VALUE && minyy3!=Double.MAX_VALUE && miny3!=Double.MAX_VALUE) {
return 1;
}
return 0;
}
答案 5 :(得分：0)
解决方案是用c ++（interviewbbit解决方案）
int Solution::solve(vector<string> &arr) {
int n=arr.size(),i;
vector<float>v;
for(i=0;i<n;i++)
{
v.push_back(stof(arr[i]));
}
float a=v[0],b=v[1],c=v[2];
float mx=0;
for(i=3;i<n;i++)
{
if(a+b+c<2 && a+b+c>1)
return 1;
else if(a+b+c>2)
{
if(a>b && a>c)
a=v[i];
else if(b>a && b>c)
b=v[i];
else
c=v[i];
}
else
{
if(a<b && a<c)
a=v[i];
else if(b<a && b<c)
b=v[i];
else
c=v[i];
}
}
if(a+b+c>1 && a+b+c<2)
return 1;
else
return 0;
}
答案 6 :(得分：0)
我们可以轻松地在O（n）中执行此操作，我们只需要找到三个最小的正实数，就可以在一次迭代中找到它们，最后如果它们的和在（1,2）之间，则返回1否则返回0。
答案 7 :(得分：0)
使用滑动窗口总和方法可以轻松地在线性运行时间中解决此问题。在这种情况下，我们将使用大小为3的窗口。这也称为“移动总和算法”。
下面的算法
1> Prepare the window of size 3 with the first 3 elements
2> IF (array.len <= 3): CHECK IF window-sum is in the range (1,2), then RETURN accordingly
3> FOR i = 3 UPTO (array.len-1)
3.1> SORT the window (3log3 = constant time operation)
3.2> IF window-sum is in the range (1,2): RETURN 1 or TRUE
3.3> ELSE IF window-sum < 1: Replace the smallest element in the window (window[0]) with array[i]
3.4> ELSE IF window-sum > 2: Replace the largest element in the window (window[2]) with array[i]
4> Outside the loop, check the FINAL window sum and RETURN accordingly.
Access the Python code here。请为存储库加上星号！
答案 8 :(得分：-5)
如上所述，整个问题是不可判定的。这是因为对于任何两个实数a和b，无法确定a > b是否成立（也请参见我的this answer）。但是，您必须至少将实数与整数值进行一次比较才能解决该问题。与整数进行比较不会使问题更容易，因为您可能有一个实数2,00...001，其中数字2和1之间有任意数量的零，这是您事先不知道的。在计算机的主存储器中存储这样的实数（可能不是每一个，但很多都是这样）对于这些特定的数字并不是一个大问题，因为它们可以用近似算法表示。
有关详细信息，建议您阅读Complexity Theory of Real Functions
相关问题
最新问题
- 我写了这段代码，但我无法理解我的错误
- 我无法从一个代码实例的列表中删除 None 值，但我可以在另一个实例中。为什么它适用于一个细分市场而不适用于另一个细分市场？
- 是否有可能使 loadstring 不可能等于打印？卢阿
- java中的random.expovariate()
- Appscript 通过会议在 Google 日历中发送电子邮件和创建活动
- 为什么我的 Onclick 箭头功能在 React 中不起作用？
- 在此代码中是否有使用“this”的替代方法？
- 在 SQL Server 和 PostgreSQL 上查询，我如何从第一个表获得第二个表的可视化
- 每千个数字得到
- 更新了城市边界 KML 文件的来源？