Question

有关该问题的详细信息，请查看-https://www.hackerrank.com/challenges/equal-stacks/problem

我们有三堆圆柱体，每个圆柱体具有相同的直径，但高度可能会有所不同。您可以通过任意次数移去并丢弃其最上面的圆柱体来更改堆栈的高度。

我们需要找到堆栈的最大可能高度，以使所有堆栈的高度完全相同。这意味着我们必须从三个堆栈的零个或多个堆栈的顶部移除零个或多个圆柱体，直到它们都具有相同的高度，然后打印高度。移除必须以使高度最大化的方式进行。

我使用三个向量实现了堆栈，并找出了三个堆栈中每个圆柱的高度之和。现在，我在每个堆栈上重复执行pop（）函数，直到其中一个堆栈变空或每个堆栈中的柱面高度总和相等为止。

//我的函数返回最大高度：

int equalStacks(vector<int> h1, vector<int> h2, vector<int> h3) 
{
     int s1 = h1.size(), s2 = h2.size(), s3 = h3.size(), sum1 = 0, 
     sum2 = 0, sum3 = 0;

     int i, j;
     for(i = 0; i < s1; i++)
        sum1 += h1[i];
     for(i = 0; i < s2; i++)
        sum2 += h2[i];
     for(i = 0; i < s3; i++)
        sum3 += h3[i];
     int height = 0;
     while(!h1.empty() && !h2.empty() && !h3.empty())
     {
         if(sum1 == sum2 && sum2 == sum3)
         {
             height = sum1;
             return height;
         }
         sum1 -= h1.back();
         sum2 -= h2.back();
         sum3 -= h2.back();

         h1.pop_back();
         h2.pop_back();
         h3.pop_back();
     }
     return height;

}

样本输入：

预期输出：

我的程序的输出：

Answer 1

问题在于您只需删除每次迭代中每个堆栈的顶部。

例如：您有三个堆栈，每个堆栈的底部都是一个5单位高的对象。现在，它们中只有一个在基座顶部还有一个1单位高的物体。这将使您的高度为5（1x5），5（1x5）和6（1x5 + 1x1）。

在您的算法中，您首先要比较总和。 “如果（5 == 5 == 6）=>否”。

然后将对象放在每个堆栈的顶部。 ->第一叠：0个单元，第二叠：0个单元，第三叠：1个单元。

看到问题了吗？

Igor提到了它，但是您首先必须搜索最大的堆栈并“逐步解决”。

Answer 2

我发现有两点需要修复。

从另一端弹出（请注意，输入是从顶部到底部）
同时删除所有三个堆栈中的元素并不能保证最佳解决方案

首先，我将反转函数开头给出的三个向量。尽管这不是很有效，但这是为了最大程度地减少对代码的更改。您不应删除第一个元素，因为它会导致['56flybox007', '45NotherFile456', '78LasstFile45'] ['56flybox', '45NotherFile', '78LasstFile']个副本，而O(N)是pop_back。

O(1)

第二，这是一个反例：

    reverse(h1.begin(), h1.end());
    reverse(h2.begin(), h2.end());
    reverse(h3.begin(), h3.end());

解决方案应为2，但它将返回0。

因此，我们可以更改策略以一次仅弹出最长的堆栈。因此，我将更改while循环，例如：

          bottom -> top
Stack 1 : 2 1
Stack 2 : 2
Stack 3 : 2

这些更改会使代码变慢一些，但不会更改时间复杂度。如果不想反转数组，则可以考虑为每个向量保留当前索引，而不是实际弹出它们。

Answer 3

看到我以前犯过同样的错误，所以现在我知道在上面的代码中要纠正什么是上述问题的解决方案。

int equalStacks(vector<int> h1, vector<int> h2, vector<int> h3) {
stack<int> stk1;
stack<int> stk2;
stack<int> stk3;

int sum1=0,sum2=0,sum3=0;
for(int i=h1.size()-1;i>=0;i--){
    sum1=sum1+h1[i];
    stk1.push(sum1);
}
for(int i=h2.size()-1;i>=0;i--){
    sum2=sum2+h2[i];
    stk2.push(sum2);
}
for(int i=h3.size()-1;i>=0;i--){
    sum3=sum3+h3[i];
    stk3.push(sum3);
}
while(1){
    if(stk1.empty()||stk2.empty()||stk3.empty()){
        return 0;
    }
    if(stk1.top()==stk2.top() && stk1.top()==stk3.top()){
        return stk1.top();
    }
    else if(stk1.top()>=stk2.top()&&stk1.top()>=stk3.top()){
        stk1.pop();
    }
    else if(stk2.top()>=stk1.top()&&stk2.top()>=stk3.top()){
        stk2.pop();
    }
    else {
        stk3.pop();
    }
}
return 0;

}

Answer 4

import math
import os
import random
import re
import sys

def isEmpty(stk):
    if(stk==[]):
        return True
    else:
        return False

def assignTop(stk):
    if(isEmpty(stk)):
        return -1
    else:
        top=len(stk)-1
        return top

def s_sum(stk):
    if(isEmpty(stk)):
        return 0
    else:
        add=0
        for i in range(len(stk)):
            add+=stk[i]
        return add 
         
def equalStacks(h1, h2, h3):
    t1=s_sum(h1)
    t2=s_sum(h2)
    t3=s_sum(h3)
    
    top1=assignTop(h1)
    top2=assignTop(h2)
    top3=assignTop(h3)
   
    greatest= []
    greatest.append(t1)
    greatest.append(t2)
    greatest.append(t3)
    if(greatest[0]==greatest[1]==greatest[2]):
        return greatest [0]
                
    isEqual = False

    while not isEqual:
        
            
        g=greatest.index(max(greatest))
        print(greatest)
      
        if(g==0):
       
            greatest[0]=greatest[0]-h1.pop((len(h1)-1)-top1)
            top1=top1-1
            
        elif(g==1):
       
            
            greatest[1]=greatest[1]-h2.pop((len(h2)-1)-top2)
            top2=top2-1
            
        else:
           
            greatest[2]=greatest[2]-h3.pop((len(h3)-1)-top3)
            top3=top3-1
        if(greatest[0]==greatest[1]==greatest[2]):
            isEqual=True
        
    return greatest[0]    
    
    
    
    
if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    first_multiple_input = input().rstrip().split()

    n1 = int(first_multiple_input[0])

    n2 = int(first_multiple_input[1])

    n3 = int(first_multiple_input[2])

    h1 = list(map(int, input().rstrip().split()))

    h2 = list(map(int, input().rstrip().split()))

    h3 = list(map(int, input().rstrip().split()))

    result = equalStacks(h1, h2, h3)

    fptr.write(str(result) + '\n')

    fptr.close()

我的平等堆栈问题逻辑在哪里？

4 个答案: