Tasks Details
The submission is being evaluated.
The submission is being evaluated.
easy
1.
StoneWall
Cover "Manhattan skyline" using the minimum number of rectangles.
Task Score
100%
Correctness
100%
Performance
100%
You are going to build a stone wall. The wall should be straight and N meters long, and its thickness should be constant; however, it should have different heights in different places. The height of the wall is specified by an array H of N positive integers. H[I] is the height of the wall from I to I+1 meters to the right of its left end. In particular, H[0] is the height of the wall's left end and H[N−1] is the height of the wall's right end.
The wall should be built of cuboid stone blocks (that is, all sides of such blocks are rectangular). Your task is to compute the minimum number of blocks needed to build the wall.
Write a function:
class Solution { public int solution(int[] H); }
that, given an array H of N positive integers specifying the height of the wall, returns the minimum number of blocks needed to build it.
For example, given array H containing N = 9 integers:
H[0] = 8 H[1] = 8 H[2] = 5 H[3] = 7 H[4] = 9 H[5] = 8 H[6] = 7 H[7] = 4 H[8] = 8the function should return 7. The figure shows one possible arrangement of seven blocks.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of array H is an integer within the range [1..1,000,000,000].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 21
Time spent on task 48 minutes
Notes
not defined yet
Code: 14:05:57 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// you can also use imports, for example:
import java.util.*;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] H) {
// write your code in Java SE 8
/*
문제:
높이가 다른 블록이 있다. 입력되는 값은 다른 높이의 블록들이다.
H[I] 는 블록의 높이를 말한다. I는 블록 왼쪽에서 오른쪽의 위치폭(?)이다.
즉, H[0]은 왼쪽 끝, H[N-1] <- 끝! 은 오른쪽 끝을 말한다.
(배열의 개수가 블록으로 채울 폭이라고 보면된다)
최소한의 블록으로 벽을 쌓을 수 있는 최소한의 블록의 개수를 구해라.
:: 이문제는 높이가 높은 블록으로 왼쪽부터 오른쪽까지 채우고 작은 블록을 그위에
쌓는 방법을 프로그래밍화 한것이다 ::
방법:
배열에 포함한 높이를 비교해 높이가 큰쪽을 사용하면된다.
즉, 이전 높이와 현재 높이를 비교해 현재 높이가 더 크면 계속 쌓아놓는다.
만약 이전 높이에 비해 현재 높이가 작으면 높이가 큰 블록을 밑에 깔기위해
꺼내서 쓴다. (현재 높이보다 큰놈이 없을때 까지 반복한다.)
이후 왼쪽부터 오른쪽까지 블록을 다 채웠으면 남은 것들을 블록위에 쌓으면 된다.
시나리오:
1. 왼쪽 -> 오른쪽 까지 반복( H[0] ~ H[N-1] 까지)
---->> 2번 반복! (현재보다 높이가 낮은 이전 블록이 나올때까지!=> 현재보다 높은 블록은 벽을 만들어야한다.)
2. 블록 저장소가 비어있지 않고 현재 블록의 높이가 이전보다 낮으면
2-1. 블록 저장소에서 빼와서 벽을 만든다.
3. 블록 저장소가 비어 있거나 현재 블록이 이전 블록보다 크면 블록저장소에 저장한다.
4. 블록 저장소에서 빼와 사용한 블록과 저장소에 남은 블록들을 더한다.
5. 더한값을 출력하면 사용된 블록이다.
*/
int block_count = 0;
Stack stack = new Stack<Integer>();
for(int i=0; i < H.length; i++){
if(!stack.empty() && stack.peek() >H[i]){
stack.pop(); // 블록 저장소에서 빼와 벽을 쌓는데 사용
block_count++; // 사용한 블록 개수 증가
}
if(stack.empty() || stack.peek() < H[i]){ // 저장소가 비었거나, 현재 높이가 더 크면
stack.push(H[i]);
}
}
block_count += stack.size(); // 높이높은걸로 벽을 쌓고 그 위에 작은걸 올린다.
return block_count;
}
}
Code: 14:08:02 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// you can also use imports, for example:
import java.util.*;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] H) {
// write your code in Java SE 8
/*
문제:
높이가 다른 블록이 있다. 입력되는 값은 다른 높이의 블록들이다.
H[I] 는 블록의 높이를 말한다. I는 블록 왼쪽에서 오른쪽의 위치폭(?)이다.
즉, H[0]은 왼쪽 끝, H[N-1] <- 끝! 은 오른쪽 끝을 말한다.
(배열의 개수가 블록으로 채울 폭이라고 보면된다)
최소한의 블록으로 벽을 쌓을 수 있는 최소한의 블록의 개수를 구해라.
:: 이문제는 높이가 높은 블록으로 왼쪽부터 오른쪽까지 채우고 작은 블록을 그위에
쌓는 방법을 프로그래밍화 한것이다 ::
방법:
배열에 포함한 높이를 비교해 높이가 큰쪽을 사용하면된다.
즉, 이전 높이와 현재 높이를 비교해 현재 높이가 더 크면 계속 쌓아놓는다.
만약 이전 높이에 비해 현재 높이가 작으면 높이가 큰 블록을 밑에 깔기위해
꺼내서 쓴다. (현재 높이보다 큰놈이 없을때 까지 반복한다.)
이후 왼쪽부터 오른쪽까지 블록을 다 채웠으면 남은 것들을 블록위에 쌓으면 된다.
시나리오:
1. 왼쪽 -> 오른쪽 까지 반복( H[0] ~ H[N-1] 까지)
---->> 2번 반복! (현재보다 높이가 낮은 이전 블록이 나올때까지!=> 현재보다 높은 블록은 벽을 만들어야한다.)
2. 블록 저장소가 비어있지 않고 현재 블록의 높이가 이전보다 낮으면
2-1. 블록 저장소에서 빼와서 벽을 만든다.
3. 블록 저장소가 비어 있거나 현재 블록이 이전 블록보다 크면 블록저장소에 저장한다.
4. 블록 저장소에서 빼와 사용한 블록과 저장소에 남은 블록들을 더한다.
5. 더한값을 출력하면 사용된 블록이다.
*/
int block_count = 0;
Stack stack = new Stack<Integer>();
for(int i=0; i < H.length; i++){
if(!stack.empty() && stack.peek().intValue() >H[i]){
stack.pop(); // 블록 저장소에서 빼와 벽을 쌓는데 사용
block_count++; // 사용한 블록 개수 증가
}
if(stack.empty() || stack.peek().intValue() < H[i]){ // 저장소가 비었거나, 현재 높이가 더 크면
stack.push(H[i]);
}
}
block_count += stack.size(); // 높이높은걸로 벽을 쌓고 그 위에 작은걸 올린다.
return block_count;
}
}
Analysis
Code: 14:12:14 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// you can also use imports, for example:
import java.util.*;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] H) {
// write your code in Java SE 8
/*
문제:
높이가 다른 블록이 있다. 입력되는 값은 다른 높이의 블록들이다.
H[I] 는 블록의 높이를 말한다. I는 블록 왼쪽에서 오른쪽의 위치폭(?)이다.
즉, H[0]은 왼쪽 끝, H[N-1] <- 끝! 은 오른쪽 끝을 말한다.
(배열의 개수가 블록으로 채울 폭이라고 보면된다)
최소한의 블록으로 벽을 쌓을 수 있는 최소한의 블록의 개수를 구해라.
:: 이문제는 높이가 높은 블록으로 왼쪽부터 오른쪽까지 채우고 작은 블록을 그위에
쌓는 방법을 프로그래밍화 한것이다 ::
방법:
배열에 포함한 높이를 비교해 높이가 큰쪽을 사용하면된다.
즉, 이전 높이와 현재 높이를 비교해 현재 높이가 더 크면 계속 쌓아놓는다.
만약 이전 높이에 비해 현재 높이가 작으면 높이가 큰 블록을 밑에 깔기위해
꺼내서 쓴다. (현재 높이보다 큰놈이 없을때 까지 반복한다.)
이후 왼쪽부터 오른쪽까지 블록을 다 채웠으면 남은 것들을 블록위에 쌓으면 된다.
시나리오:
1. 왼쪽 -> 오른쪽 까지 반복( H[0] ~ H[N-1] 까지)
---->> 2번 반복! (현재보다 높이가 낮은 이전 블록이 나올때까지!=> 현재보다 높은 블록은 벽을 만들어야한다.)
2. 블록 저장소가 비어있지 않고 현재 블록의 높이가 이전보다 낮으면
2-1. 블록 저장소에서 빼와서 벽을 만든다.
3. 블록 저장소가 비어 있거나 현재 블록이 이전 블록보다 크면 블록저장소에 저장한다.
4. 블록 저장소에서 빼와 사용한 블록과 저장소에 남은 블록들을 더한다.
5. 더한값을 출력하면 사용된 블록이다.
*/
int block_count = 0;
Stack stack = new Stack<Integer>();
for(int i=0; i < H.length; i++){
if(!stack.empty() && (int)stack.peek >H[i]){
stack.pop(); // 블록 저장소에서 빼와 벽을 쌓는데 사용
block_count++; // 사용한 블록 개수 증가
}
if(stack.empty() || (int)stack.peek() < H[i]){ // 저장소가 비었거나, 현재 높이가 더 크면
stack.push(H[i]);
}
}
block_count += stack.size(); // 높이높은걸로 벽을 쌓고 그 위에 작은걸 올린다.
return block_count;
}
}
Analysis
expand all
Example tests
1.
1.480 s
OK
stderr:
WARNING: producing output may seriously slow down your code!stdout:
block_count : 5 stack_size : 2
Code: 14:12:33 UTC,
java,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// you can also use imports, for example:
import java.util.*;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] H) {
// write your code in Java SE 8
/*
문제:
높이가 다른 블록이 있다. 입력되는 값은 다른 높이의 블록들이다.
H[I] 는 블록의 높이를 말한다. I는 블록 왼쪽에서 오른쪽의 위치폭(?)이다.
즉, H[0]은 왼쪽 끝, H[N-1] <- 끝! 은 오른쪽 끝을 말한다.
(배열의 개수가 블록으로 채울 폭이라고 보면된다)
최소한의 블록으로 벽을 쌓을 수 있는 최소한의 블록의 개수를 구해라.
:: 이문제는 높이가 높은 블록으로 왼쪽부터 오른쪽까지 채우고 작은 블록을 그위에
쌓는 방법을 프로그래밍화 한것이다 ::
방법:
배열에 포함한 높이를 비교해 높이가 큰쪽을 사용하면된다.
즉, 이전 높이와 현재 높이를 비교해 현재 높이가 더 크면 계속 쌓아놓는다.
만약 이전 높이에 비해 현재 높이가 작으면 높이가 큰 블록을 밑에 깔기위해
꺼내서 쓴다. (현재 높이보다 큰놈이 없을때 까지 반복한다.)
이후 왼쪽부터 오른쪽까지 블록을 다 채웠으면 남은 것들을 블록위에 쌓으면 된다.
시나리오:
1. 왼쪽 -> 오른쪽 까지 반복( H[0] ~ H[N-1] 까지)
---->> 2번 반복! (현재보다 높이가 낮은 이전 블록이 나올때까지!=> 현재보다 높은 블록은 벽을 만들어야한다.)
2. 블록 저장소가 비어있지 않고 현재 블록의 높이가 이전보다 낮으면
2-1. 블록 저장소에서 빼와서 벽을 만든다.
3. 블록 저장소가 비어 있거나 현재 블록이 이전 블록보다 크면 블록저장소에 저장한다.
4. 블록 저장소에서 빼와 사용한 블록과 저장소에 남은 블록들을 더한다.
5. 더한값을 출력하면 사용된 블록이다.
*/
int block_count = 0;
Stack stack = new Stack<Integer>();
for(int i=0; i < H.length; i++){
if(!stack.empty() && (int)stack.peek() >H[i]){
stack.pop(); // 블록 저장소에서 빼와 벽을 쌓는데 사용
block_count++; // 사용한 블록 개수 증가
}
if(stack.empty() || (int)stack.peek() < H[i]){ // 저장소가 비었거나, 현재 높이가 더 크면
stack.push(H[i]);
}
}
block_count += stack.size(); // 높이높은걸로 벽을 쌓고 그 위에 작은걸 올린다.
return block_count;
}
}
Analysis
expand all
Example tests
1.
1.496 s
WRONG ANSWER,
got 6 expected 7
stderr:
WARNING: producing output may seriously slow down your code!stdout:
block_count : 4 stack_size : 2
Code: 14:14:55 UTC,
java,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// you can also use imports, for example:
import java.util.*;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] H) {
// write your code in Java SE 8
/*
문제:
높이가 다른 블록이 있다. 입력되는 값은 다른 높이의 블록들이다.
H[I] 는 블록의 높이를 말한다. I는 블록 왼쪽에서 오른쪽의 위치폭(?)이다.
즉, H[0]은 왼쪽 끝, H[N-1] <- 끝! 은 오른쪽 끝을 말한다.
(배열의 개수가 블록으로 채울 폭이라고 보면된다)
최소한의 블록으로 벽을 쌓을 수 있는 최소한의 블록의 개수를 구해라.
:: 이문제는 높이가 높은 블록으로 왼쪽부터 오른쪽까지 채우고 작은 블록을 그위에
쌓는 방법을 프로그래밍화 한것이다 ::
방법:
배열에 포함한 높이를 비교해 높이가 큰쪽을 사용하면된다.
즉, 이전 높이와 현재 높이를 비교해 현재 높이가 더 크면 계속 쌓아놓는다.
만약 이전 높이에 비해 현재 높이가 작으면 높이가 큰 블록을 밑에 깔기위해
꺼내서 쓴다. (현재 높이보다 큰놈이 없을때 까지 반복한다.)
이후 왼쪽부터 오른쪽까지 블록을 다 채웠으면 남은 것들을 블록위에 쌓으면 된다.
시나리오:
1. 왼쪽 -> 오른쪽 까지 반복( H[0] ~ H[N-1] 까지)
---->> 2번 반복! (현재보다 높이가 낮은 이전 블록이 나올때까지!=> 현재보다 높은 블록은 벽을 만들어야한다.)
2. 블록 저장소가 비어있지 않고 현재 블록의 높이가 이전보다 낮으면
2-1. 블록 저장소에서 빼와서 벽을 만든다.
3. 블록 저장소가 비어 있거나 현재 블록이 이전 블록보다 크면 블록저장소에 저장한다.
4. 블록 저장소에서 빼와 사용한 블록과 저장소에 남은 블록들을 더한다.
5. 더한값을 출력하면 사용된 블록이다.
*/
int block_count = 0;
Stack stack = new Stack<Integer>();
for(int i=0; i < H.length; i++){
if(!stack.empty() && (int)stack.peek() >H[i]){
stack.pop(); // 블록 저장소에서 빼와 벽을 쌓는데 사용
block_count++; // 사용한 블록 개수 증가
}
if(stack.empty() || (int)stack.peek() < H[i]){ // 저장소가 비었거나, 현재 높이가 더 크면
stack.push(H[i]);
}
}
System.out.println("block_count : " + block_count + " stack_size : " + stack.size());
block_count += stack.size(); // 높이높은걸로 벽을 쌓고 그 위에 작은걸 올린다.
return block_count;
}
}
Analysis
expand all
Example tests
1.
1.468 s
WRONG ANSWER,
got 6 expected 7
Code: 14:17:20 UTC,
java,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// you can also use imports, for example:
import java.util.*;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] H) {
// write your code in Java SE 8
/*
문제:
높이가 다른 블록이 있다. 입력되는 값은 다른 높이의 블록들이다.
H[I] 는 블록의 높이를 말한다. I는 블록 왼쪽에서 오른쪽의 위치폭(?)이다.
즉, H[0]은 왼쪽 끝, H[N-1] <- 끝! 은 오른쪽 끝을 말한다.
(배열의 개수가 블록으로 채울 폭이라고 보면된다)
최소한의 블록으로 벽을 쌓을 수 있는 최소한의 블록의 개수를 구해라.
:: 이문제는 높이가 높은 블록으로 왼쪽부터 오른쪽까지 채우고 작은 블록을 그위에
쌓는 방법을 프로그래밍화 한것이다 ::
방법:
배열에 포함한 높이를 비교해 높이가 큰쪽을 사용하면된다.
즉, 이전 높이와 현재 높이를 비교해 현재 높이가 더 크면 계속 쌓아놓는다.
만약 이전 높이에 비해 현재 높이가 작으면 높이가 큰 블록을 밑에 깔기위해
꺼내서 쓴다. (현재 높이보다 큰놈이 없을때 까지 반복한다.)
이후 왼쪽부터 오른쪽까지 블록을 다 채웠으면 남은 것들을 블록위에 쌓으면 된다.
시나리오:
1. 왼쪽 -> 오른쪽 까지 반복( H[0] ~ H[N-1] 까지)
---->> 2번 반복! (현재보다 높이가 낮은 이전 블록이 나올때까지!=> 현재보다 높은 블록은 벽을 만들어야한다.)
2. 블록 저장소가 비어있지 않고 현재 블록의 높이가 이전보다 낮으면
2-1. 블록 저장소에서 빼와서 벽을 만든다.
3. 블록 저장소가 비어 있거나 현재 블록이 이전 블록보다 크면 블록저장소에 저장한다.
4. 블록 저장소에서 빼와 사용한 블록과 저장소에 남은 블록들을 더한다.
5. 더한값을 출력하면 사용된 블록이다.
*/
int block_count = 0;
Stack stack = new Stack<Integer>();
for(int i=0; i < H.length; i++){
while(!stack.empty() && (int)stack.peek() >H[i]){
stack.pop(); // 블록 저장소에서 빼와 벽을 쌓는데 사용
block_count++; // 사용한 블록 개수 증가
}
if(stack.empty() || (int)stack.peek() < H[i]){ // 저장소가 비었거나, 현재 높이가 더 크면
stack.push(H[i]);
}
}
System.out.println("block_count : " + block_count + " stack_size : " + stack.size());
block_count += stack.size(); // 높이높은걸로 벽을 쌓고 그 위에 작은걸 올린다.
return block_count;
}
}
Analysis
Compile error
Solution.java:43: error: cannot find symbol
if(!stack.empty() && (int)stack.peek >H[i]){
^
symbol: variable peek
location: variable stack of type Stack
Note: Solution.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
1 error
Code: 14:18:17 UTC,
java,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// you can also use imports, for example:
import java.util.*;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] H) {
// write your code in Java SE 8
/*
문제:
높이가 다른 블록이 있다. 입력되는 값은 다른 높이의 블록들이다.
H[I] 는 블록의 높이를 말한다. I는 블록 왼쪽에서 오른쪽의 위치폭(?)이다.
즉, H[0]은 왼쪽 끝, H[N-1] <- 끝! 은 오른쪽 끝을 말한다.
(배열의 개수가 블록으로 채울 폭이라고 보면된다)
최소한의 블록으로 벽을 쌓을 수 있는 최소한의 블록의 개수를 구해라.
:: 이문제는 높이가 높은 블록으로 왼쪽부터 오른쪽까지 채우고 작은 블록을 그위에
쌓는 방법을 프로그래밍화 한것이다 ::
방법:
배열에 포함한 높이를 비교해 높이가 큰쪽을 사용하면된다.
즉, 이전 높이와 현재 높이를 비교해 현재 높이가 더 크면 계속 쌓아놓는다.
만약 이전 높이에 비해 현재 높이가 작으면 높이가 큰 블록을 밑에 깔기위해
꺼내서 쓴다. (현재 높이보다 큰놈이 없을때 까지 반복한다.)
이후 왼쪽부터 오른쪽까지 블록을 다 채웠으면 남은 것들을 블록위에 쌓으면 된다.
시나리오:
1. 왼쪽 -> 오른쪽 까지 반복( H[0] ~ H[N-1] 까지)
---->> 2번 반복! (현재보다 높이가 낮은 이전 블록이 나올때까지!=> 현재보다 높은 블록은 벽을 만들어야한다.)
2. 블록 저장소가 비어있지 않고 현재 블록의 높이가 이전보다 낮으면
2-1. 블록 저장소에서 빼와서 벽을 만든다.
3. 블록 저장소가 비어 있거나 현재 블록이 이전 블록보다 크면 블록저장소에 저장한다.
4. 블록 저장소에서 빼와 사용한 블록과 저장소에 남은 블록들을 더한다.
5. 더한값을 출력하면 사용된 블록이다.
*/
int block_count = 0;
Stack stack = new Stack<Integer>();
for(int i=0; i < H.length; i++){
while(!stack.empty() && (int)stack.peek() >H[i]){ // 현재 블록 높이 보다 이전것의 높이가 더 크다면 낮은게 나올때까지 계속 반복해서 저장소에서 빼 벽을 만든다.
stack.pop(); // 블록 저장소에서 빼와 벽을 쌓는데 사용
block_count++; // 사용한 블록 개수 증가
}
if(stack.empty() || (int)stack.peek() < H[i]){ // 저장소가 비었거나, 현재 높이가 더 크면
stack.push(H[i]);
}
}
// System.out.println("block_count : " + block_count + " stack_size : " + stack.size());
block_count += stack.size(); // 높이높은걸로 벽을 쌓고 그 위에 작은걸 올린다.
return block_count;
}
}
Analysis
Compile error
Solution.java:43: error: cannot find symbol
if(!stack.empty() && stack.peek().intValue() >H[i]){
^
symbol: method intValue()
location: class Object
Solution.java:48: error: cannot find symbol
if(stack.empty() || stack.peek().intValue() < H[i]){ // ???? ????, ?? ??? ? ??
^
symbol: method intValue()
location: class Object
Note: Solution.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
2 errors
Code: 14:18:27 UTC,
java,
final,
score:
100
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// you can also use imports, for example:
import java.util.*;
// you can use System.out.println for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] H) {
// write your code in Java SE 8
/*
문제:
높이가 다른 블록이 있다. 입력되는 값은 다른 높이의 블록들이다.
H[I] 는 블록의 높이를 말한다. I는 블록 왼쪽에서 오른쪽의 위치폭(?)이다.
즉, H[0]은 왼쪽 끝, H[N-1] <- 끝! 은 오른쪽 끝을 말한다.
(배열의 개수가 블록으로 채울 폭이라고 보면된다)
최소한의 블록으로 벽을 쌓을 수 있는 최소한의 블록의 개수를 구해라.
:: 이문제는 높이가 높은 블록으로 왼쪽부터 오른쪽까지 채우고 작은 블록을 그위에
쌓는 방법을 프로그래밍화 한것이다 ::
방법:
배열에 포함한 높이를 비교해 높이가 큰쪽을 사용하면된다.
즉, 이전 높이와 현재 높이를 비교해 현재 높이가 더 크면 계속 쌓아놓는다.
만약 이전 높이에 비해 현재 높이가 작으면 높이가 큰 블록을 밑에 깔기위해
꺼내서 쓴다. (현재 높이보다 큰놈이 없을때 까지 반복한다.)
이후 왼쪽부터 오른쪽까지 블록을 다 채웠으면 남은 것들을 블록위에 쌓으면 된다.
시나리오:
1. 왼쪽 -> 오른쪽 까지 반복( H[0] ~ H[N-1] 까지)
---->> 2번 반복! (현재보다 높이가 낮은 이전 블록이 나올때까지!=> 현재보다 높은 블록은 벽을 만들어야한다.)
2. 블록 저장소가 비어있지 않고 현재 블록의 높이가 이전보다 낮으면
2-1. 블록 저장소에서 빼와서 벽을 만든다.
3. 블록 저장소가 비어 있거나 현재 블록이 이전 블록보다 크면 블록저장소에 저장한다.
4. 블록 저장소에서 빼와 사용한 블록과 저장소에 남은 블록들을 더한다.
5. 더한값을 출력하면 사용된 블록이다.
*/
int block_count = 0;
Stack stack = new Stack<Integer>();
for(int i=0; i < H.length; i++){
while(!stack.empty() && (int)stack.peek() >H[i]){ // 현재 블록 높이 보다 이전것의 높이가 더 크다면 낮은게 나올때까지 계속 반복해서 저장소에서 빼 벽을 만든다.
stack.pop(); // 블록 저장소에서 빼와 벽을 쌓는데 사용
block_count++; // 사용한 블록 개수 증가
}
if(stack.empty() || (int)stack.peek() < H[i]){ // 저장소가 비었거나, 현재 높이가 더 크면
stack.push(H[i]);
}
}
// System.out.println("block_count : " + block_count + " stack_size : " + stack.size());
block_count += stack.size(); // 높이높은걸로 벽을 쌓고 그 위에 작은걸 올린다.
return block_count;
}
}