我的 Equal Stacks 问题逻辑中的问题在哪里？答案

【问题标题】：Where is the problem in my logic for the Equal Stacks problem?我的 Equal Stacks 问题逻辑中的问题在哪里？
【发布时间】：2019-02-03 20:39:44
【问题描述】：

有关问题的详细信息，请查看 - 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;

}

示例输入：

预期输出：

我的程序的输出：

【问题讨论】：

在每个步骤中，您要同时移除三个气缸，每个堆栈一个。相反，您应该每次从最高的堆栈（或至少从不是最短的堆栈）中逐一删除它们。

标签： c++11 stack

【解决方案1】：

问题是你只是在每次迭代中移除每个栈的栈顶。

例如：您有三个堆栈，所有堆栈的底部都是一个 5 单位高的物体。现在只有其中一个在底座顶部也有一个 1 单位高的物体；这将为您提供 5 (1x5)、5 (1x5) 和 6 (1x5 + 1x1) 的高度。

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

然后你把每个堆栈顶部的对象拿走。 -> 第一个堆栈：0 个单位，第二个堆栈：0 个单位，第三个堆栈 1 个单位。

你看到问题了吗？

Igor 提到了它，但您首先必须搜索最大的堆栈并“向下工作”。

【讨论】：

【解决方案2】：

我发现有两件事需要修复。

从其他方式弹出（注意输入是从 TOP 到 BOTTOM 给出的）
同时从所有三个堆栈中删除元素并不能保证最佳解决方案

首先，我将反转函数开头给出的三个向量。虽然这不是很有效，但这是为了最大限度地减少对代码的更改。您不应该删除第一个元素，因为它会导致 O(N) 复制，而 pop_back 是 O(1)。

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

对于第二个，这里有一个反例：

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

解决方案应该是 2，但它会返回 0。

所以我们可以改变策略，一次只弹出最长的堆栈。所以我会改变while循环：

     while(!h1.empty() && !h2.empty() && !h3.empty())
     {
         if(sum1 == sum2 && sum2 == sum3)
         {
             height = sum1;
             return height;
         }

         if (sum1 >= sum2 && sum1 >= sum3)
         {
             sum1 -= h1.back();
             h1.pop_back();
         }
         else if (sum2 >= sum1 && sum2 >= sum3)
         {
             sum2 -= h2.back();
             h2.pop_back();
         }
         else
         {
             sum3 -= h3.back();
             h3.pop_back();
         }
     }

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

【讨论】：

【解决方案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;

}

【讨论】：

【解决方案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()

【讨论】：