๋ฌธ์ ๋งํฌ
https://www.acmicpc.net/problem/2460
ํ๊ธฐ ์ ์ ์์ด๋์ด
๊ธฐ์ฐจ๋ ์ด 10๊ฐ์ ์ ์ฐจ์ญ์ด ์๋ ๋ ธ์ ์์ ์ดํ๋๊ณ ์๋ค. -> for๋ฌธ์ผ๋ก 10๋ฒ ๋๋ ค์ ๋ด๋ฆฌ๊ณ ํ ์ฌ๋ ์๋ฅผ ์ ๋ ฅ๋ฐ์์ผ๊ฒ ๋ค.
๋ด๋ฆด ์ฌ๋์ด ๋ชจ๋ ๋ด๋ฆฌ๊ณ ํ๋ค. -> ์ด์จ๋ ํ ์ญ์์ (ํ ์ฌ๋ ์ - ๋ด๋ฆฐ ์ฌ๋ ์)๋ฅผ ์ฒดํฌํ๋ฉด ๋๊ฒ ๋ค.
์ญ ๋ฒํธ ์์๋๋ก ์ดํ๋๋ค. -> ์ ๋ ฅ๋ฐ์ ์์๋๋ก ๊ธฐ์ฐจ์ ํ ์ฌ๋์ด ๋ช ๋ช ์ธ์ง ์ธ๋ณด์.
๊ธฐ์ฐจ์ ์ฌ๋์ด ๊ฐ์ฅ ๋ง์ ๋์ ์ฌ๋ ์๋ฅผ ๊ตฌํด์ผ ํ๋๋ฐ, ๊ทธ๋ฌ๋ฉด 1๋ฒ ์ ์ฐจ์ญ์์ ๊ฐ์ฅ ๋ง๋ค๊ณ ๊ฐ์ ํ์ฌ ์ฌ๋ ์๋ฅผ ์ ์ฅํด ๋ฌ์ผ๊ฒ ๋ค. ๊ทธ๋ค์์ ์ ์ฐจ์ญ์ ์ง๋ ๋๋ง๋ค ์ ์ฅํด ๋ ์ฌ๋ ์๋ ๋น๊ตํด์ ๋ ๋ง์์ง๋ฉด ๊ฐ์ ๋ค์ ๋ฐ๊ฟ์ฃผ๊ณ ์๋๋ฉด ์ ๋ฐ๊ฟ์ฃผ๋ฉด ๋๊ฒ ๋ค~!
๊ณผ์
์ฐ์ ์ ๋ ฅ์ ๋ฐ์์ผ ํ๋๋ฐ, ์๋ ๊ฐ์ผ๋ฉด ๋ฐ๋ก Scanner๋ก ์์.. ํ๊ฒ ์ง๋ง ์ ๋ง ์ต์ํ์ง ์์ BufferdReader๋ฅผ ์ฌ์ฉํด ๋ณด๊ธฐ๋ก ํ๋ค.
BufferdReader๊ฐ ์ง์ง ๋น ๋ฅด๊ณ ํจ์จ์ ์ด๋ผ๊ณ ํ๋ค! ์ด๋ ค์ด ๋ฌธ์ ํ๋ค ๋ณด๋ฉด ์๊ฐ์ด๊ณผ ๋์ ํต๊ณผ ๋ชปํ๋ ๊ฒฝ์ฐ๊ฐ ์์ด์ ๊ทธ๋๋ง ์จ๋ณด๋ค๊ฐ.. ์ด๋ ๊ฒ ๋ค์ ์ฌ์ฉ์ ํด๋ณธ๋ค.. (์ต์ํ์ง ์์ ๊ฑด ๋ค ์ด๋ ค์ด ๊ฑฐ์ผ..)
<์ /์ถ๋ ฅ ์๋๋ฅผ ๋์ด๊ธฐ ์ํ ๋ฐฉ๋ฒ>
- ์ ๋ ฅ: BufferdReader, StringTokenizer
- ์ถ๋ ฅ: StringBuilder
์จ๋ ! BufferdReader๊ฐ Scanner๋ณด๋ค ๋น ๋ฅธ ์ด์ ๋ ๋ฒํผ๋ฅผ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ด๋ค.
Scanner๋ ํค๋ณด๋๋ก ์ ๋ ฅํ๋ฉด ๋ฐ๋ก ์ ๋ฌ๋๋๋ฐ, ๋ฒํผ๋ฅผ ์ฌ์ฉํ๋ฉด ์ ๋ ฅ๋ ๋ฌธ์ ํ๋์ฉ ์ ์ฅํด ๋๋ค๊ฐ ํ ๋ฒ์ ์ ์กํ๋ ๊ฑฐ๋ผ์ ๋น ๋ฅธ ๊ฒ์ด๋ค!
BufferdReader๋ฅผ ์ฐ๋ฉด 'throws IOException'์ ๋ถ์ฌ์ค์ผ ํ๋๋ฐ ์ด๊ฑฐ ์ ๋ถ์ด๋ ์ถ์ด์ ๊ฒ์ํด ๋ณด์๋ค.
์ฌ์ฉ์์ ์ ๋ ฅ์ด ๋ค์ํ ํ์ ์ผ๋ก ๋ค์ด์ฌ ์๊ฐ ์๋๋ฐ, ์๋ชป๋ ๊ฐ์ด ๋ค์ด์ฌ ๊ฒฝ์ฐ์ ์๋ฌ๊ฐ ๋์ง ์๋๋ก ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ค์ผ ํ๋ค๊ณ ํ๋ค. Scanner๋ฅผ ์ธ ๋ ์ ๊ฒ ํ์ ์๋ ์ด์ ๋ ๋ด๋ถ์์ try-catch๋ก ์์ธ์ฒ๋ฆฌ๋ฅผ ํ๊ธฐ ๋๋ฌธ์ด๋ผ๊ณ ํ๋ค.
์ด์ BufferReader์ ๋ํด์ ๊ณต๋ถํด ๋ดค์ผ๋๊น ์ง์ ์ฌ์ฉ์ ํด๋ด์ผ ํ๋๋ฐ.. ์ฒ์์๋ ใ ใ ใ ใ
int getOff = br.read();
์ด๋ ๊ฒ ์ผ๋๋ฐ ใ ใ ์๋ ๊ฐ์ด ์ด์ํ๊ฒ ๋์ค๋ ๊ฑฐ ใ ใ ๋งค์ฐ ๋นํฉ.. ๊ทธ๋์ ๋๋ฒ๊น ์ ํด๋ดค๋๋ฐ ๋ด๊ฐ ์ ๋ ฅํ ์ซ์๋ ๋ค๋ฅธ ์ซ์๊ฐ ๋์ค๋ ๊ฑฐ.. ๋๋์ด ์ธํ๋ค. ๋ ๊ตฌ๊ธ๋ง์ ํ๋ค.
์๊ณ ๋ณด๋ read() ๋ฉ์๋๋ ๊ฐ์ ์ฝ์ ๋ int ๊ฐ์ผ๋ก ๋ณํํ์ฌ ์ฝ์ด์ค๋ ๊ฑฐ๋ผ ํ๋ค. ๊ทธ๋์ ์ด๊ฒ ๋ฌด์จ ์๋ฆฌ๋๋ฉด ๋ด๊ฐ 1์ ์ ๋ ฅํ๋ฉด intํ ์ซ์ 1์ ์ฝ๋ ๊ฒ ์๋๋ผ, ์์คํค ํ์์ ๋ฌธ์๊ฐ 1์ ์ฝ์ด์ค๋ ๊ฑฐ๋ผ์ ๊ฒฐ๊ตญ 49๋ฅผ ์ฝ์ด์ค๋ ๊ฑฐ์๋ค. ์ด๊ฒ๋ ๋ฌธ์ ๊ณ ๋ด๋ฆฌ๋ ์ฌ๋, ํ๋ ์ฌ๋์ ๊ฐ๊ฐ ๋ฐ์ดํธ ๋จ์๋ก ์ฝ์ด์ ์ด์ํ๊ฒ ๋์ค๋ ๊ฑฐ๋ผ๊ณ ํ๋ค.
๋ด๊ฐ ๊ตฌํํ ์ฝ๋๋ฅผ Scanner ์ฌ์ฉํด์ ๋๋ฆฌ๋ฉด ์์ ์ฝ๋ ์ถ๋ ฅ์ด๋ ๊ฐ๊ฒ ๋์ค๋๋ฐ ์ ๋ฐฉ์๋๋ก ํด๋ณด๋ฉด ์ด์ํ๊ฒ ๋์์ ์ฐพ์๋ณด๊ฒ ๋์๋ค. ์ข์ ๊ฒฝํ ํ๋ค(^_^)
๊ทธ๋์ ์ด๋ป๊ฒ ํ๋ฉด ์ ๋๋ก ๊ฐ์ ์ฝ์ ์ ์์๊น? ๊ณต๋ถ๋ฅผ ํด ๋ณธ ๊ฒฐ๊ณผ BufferedReader๋ ์ ๋ ฅํ ๋ฐ์ดํฐ๋ฅผ ๋ฌธ์์ด ํํ๋ก ์ ๊ณตํ๊ธฐ ๋๋ฌธ์ Integer.parseInt๋ฅผ ํตํด ์ ์ํ ๋ณ์๋ก ๋ณํํด์ค์ผ ํ๋ค.
String[] input = br.readLine().split(" ");
int getOff = Integer.parseInt(input[0]);
int getOn = Integer.parseInt(input[1]);
์์ ์ ๋ ฅ์ด 0, 32 ์ด๋ฐ ์์ธ๋ฐ ์ด๊ฑธ ํ ์ค์ ๋ค ์ฝ๊ณ , ๊ณต๋ฐฑ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ๋๋ ์ค๋ค. ๊ทธ๋ฌ๋ฉด input ๋ฐฐ์ด์ ์ ์ฅ์ด ๋๊ณ [0, 32] ์ด๋ ๊ฒ ์ ์ฅ์ด ๋๋ ๊ฑฐ์ง! ๊ทธ๋์ ๋ด๋ฆฐ ์ฌ๋์ input ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฐ์ผ๋ก, ํ ์ฌ๋์ ๋ฐฐ์ด์ ๋ ๋ฒ์งธ ๊ฐ์ผ๋ก ์ง์ ํด์ ๋ฌธ์ ๋ฅผ ํ์๋ค.
๊ทผ๋ฐ ์ ๋ฐฉ๋ฒ ๋ง๊ณ ๋ ๋ ์ข์ ๋ฐฉ๋ฒ์ด ์๊ฐ๋ฌ๋ค.
StringTokenizer๋ฅผ ์ฌ์ฉํ๋ ๊ฑฐ์๋ค. ์ด๊ฑธ ์ฌ์ฉํ๋ฉด split ๋ฉ์๋๋ก ๋ฌธ์์ด์ ๋๋๋ ๊ฑฐ๋ณด๋ค ๋น ๋ฅด๋ค๊ณ ํ๋ค. ๊ทธ๊ฑฐ ๋ง๊ณ ๋ ๋ญ ๊ตฌ๋ถ์ ์ง์ ์ด ๊ฐ๋ฅํด์ ๋ ์ ์ฐํ๊ฒ ์ฌ์ฉํ ์ ์๋ค๊ณ ํ๋ค. ์ด๊ฒ ๊ทนํ์ ํจ์จ์ถฉ..?
StringTokenizer st = new StringTokenizer(br.readLine());
int getOff = Integer.parseInt(st.nextToken());
int getOn = Integer.parseInt(st.nextToken());
์ด๊ฒ๋ ๊ฒฐ๊ตญ br๋ก ํ ์ค ์ฝ๊ณ , ๋ฐ๋ก ๋ถํ ๋ฌธ์์ด์ ์ง์ ํ์ง ์์์ผ๋ฉด ๊ธฐ๋ณธ์ผ๋ก ๊ณต๋ฐฑ ๋ฌธ์๋ฅผ ๊ตฌ๋ถ์๋ก ์ฌ์ฉํ๋ค๊ณ ํ๋ค! ๊ทธ๋ฆฌ๊ณ nextToken() ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ๋ถํ ๋ ๋ฌธ์์ด ํ๋๋ฅผ ๊ฐ์ ธ์์ ์ ์๋ก ๋ณํํ๋ ๊ฒ์ด๋ค. ์ ๊ธฐ๋ฐฉ๊ธฐํจ๋๋ค.
๊ทธ๋์ ์ด์ ๋ฌธ์ ์ด๋ป๊ฒ ํ์๋๋ฉด..
๋ด๊ฐ ํ๊ธฐ ์ ์ ์๊ฐํ ๋ฐฉ๋ฒ๋๋ก ํ์ฌ ๊ธฐ์ฐจ์ ํ ์น๊ฐ ์๋ฅผ count๋ก ์ง์ ํด ๋๊ณ , ์ ์ผ ๋ง์ด ํ์ ๋๋ ๊ณ์ ๋น๊ตํด ๊ฐ๋ฉด์ ์ ์ผ ์ฌ๋ ๋ง์ ๋์ count๋ฅผ maxNum์ ์ ๋ฐ์ดํธํด ์ฃผ์๋ค.
tmi: StringBuilder๋ ๋์ค์ ์จ๋ณผ๊ฒ์..
์๊ฐ ๋ณต์ก๋
: O(1)
์ฝ๊ฐ ๊ถ๊ธํ ๊ฒ ์๊ธด ๊ฒ์ด์ผ
- Scanner ์ฌ์ฉ
- BufferdReader ์ฌ์ฉ
- BufferdReader + StringTokenizer ์ฌ์ฉ
์ด๋ ๊ฒ 3๊ฐ์ง ์ผ์ด์ค๋ก ์ ์ถํด ๋ดค๋๋ฐ, ์ ์ง์ง ๋ฉ๋ชจ๋ฆฌ๋ ์๊ฐ ํํ ์ค์ด๋๋ ๊ฑฐ ์ ๊ธฐํ๋ค!! ํ์คํ BufferReader๊ฐ ์ง์ง ์๋๊ฐ ๋น ๋ฅด๊ธด ํ๋๋ณด๋ค. ์ด๋ฒ ๋ฌธ์ ์ฝ๋๊ฐ ๊ฐ๋จํด์ ๊ทธ๋ ์ง ๋ณต์กํ ์ฝ๋์์๋ ์์ฒญ๋ ํจ์จ์ ์๋ํ ๊ฒ ๊ฐ๋ค.. ๋นจ๋ฆฌ ์นํด์ง์ ๋๋..๐ฅน
์ ์ฒด ์ฝ๋
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int maxNum = 0;
int count = 0;
for (int i = 0; i < 10; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
int getOff = Integer.parseInt(st.nextToken());
int getOn = Integer.parseInt(st.nextToken());
count += getOn - getOff;
if (maxNum < count) {
maxNum = count;
}
}
System.out.println(maxNum);
}
}