[BaekJoon] 10810๋ฒ - ๊ณต ๋ฃ๊ธฐ (java)
๐ 1. ๋ฌธ์
๐ ๋ฌธ์ ๋ฐ๋ก๊ฐ๊ธฐ
- ์กฐ๊ฑด
์๊ฐ ์ ํ | ๋ฉ๋ชจ๋ฆฌ ์ ํ |
---|---|
1์ด | 256MB |
- ๋ฌธ์
๋ํ์ด๋ ๋ฐ๊ตฌ๋๋ฅผ ์ด N๊ฐ ๊ฐ์ง๊ณ ์๊ณ , ๊ฐ๊ฐ์ ๋ฐ๊ตฌ๋์๋ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฒํธ๊ฐ ๋งค๊ฒจ์ ธ ์๋ค. ๋, 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฒํธ๊ฐ ์ ํ์๋ ๊ณต์ ๋งค์ฐ ๋ง์ด ๊ฐ์ง๊ณ ์๋ค. ๊ฐ์ฅ ์ฒ์ ๋ฐ๊ตฌ๋์๋ ๊ณต์ด ๋ค์ด์์ง ์์ผ๋ฉฐ, ๋ฐ๊ตฌ๋์๋ ๊ณต์ 1๊ฐ๋ง ๋ฃ์ ์ ์๋ค.
๋ํ์ด๋ ์์ผ๋ก M๋ฒ ๊ณต์ ๋ฃ์ผ๋ ค๊ณ ํ๋ค. ๋ํ์ด๋ ํ ๋ฒ ๊ณต์ ๋ฃ์ ๋, ๊ณต์ ๋ฃ์ ๋ฐ๊ตฌ๋ ๋ฒ์๋ฅผ ์ ํ๊ณ , ์ ํ ๋ฐ๊ตฌ๋์ ๋ชจ๋ ๊ฐ์ ๋ฒํธ๊ฐ ์ ํ์๋ ๊ณต์ ๋ฃ๋๋ค. ๋ง์ฝ, ๋ฐ๊ตฌ๋์ ๊ณต์ด ์ด๋ฏธ ์๋ ๊ฒฝ์ฐ์๋ ๋ค์ด์๋ ๊ณต์ ๋นผ๊ณ , ์๋ก ๊ณต์ ๋ฃ๋๋ค. ๊ณต์ ๋ฃ์ ๋ฐ๊ตฌ๋๋ ์ฐ์๋์ด ์์ด์ผ ํ๋ค.
๊ณต์ ์ด๋ป๊ฒ ๋ฃ์์ง๊ฐ ์ฃผ์ด์ก์ ๋, M๋ฒ ๊ณต์ ๋ฃ์ ์ดํ์ ๊ฐ ๋ฐ๊ตฌ๋์ ์ด๋ค ๊ณต์ด ๋ค์ด ์๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
- ์ ๋ ฅ
๋ํ์ด๋ ์
๋ ฅ์ผ๋ก ์ฃผ์ด์ง ์์๋๋ก ๊ณต์ ๋ฃ๋๋ค.
์ฒซ์งธ ์ค์ N (1 โค N โค 100)๊ณผ M (1 โค M โค 100)์ด ์ฃผ์ด์ง๋ค.
๋์งธ ์ค๋ถํฐ M๊ฐ์ ์ค์ ๊ฑธ์ณ์ ๊ณต์ ๋ฃ๋ ๋ฐฉ๋ฒ์ด ์ฃผ์ด์ง๋ค. ๊ฐ ๋ฐฉ๋ฒ์ ์ธ ์ ์ i j k๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, i๋ฒ ๋ฐ๊ตฌ๋๋ถํฐ j๋ฒ ๋ฐ๊ตฌ๋๊น์ง์ k๋ฒ ๋ฒํธ๊ฐ ์ ํ์ ธ ์๋ ๊ณต์ ๋ฃ๋๋ค๋ ๋ป์ด๋ค. ์๋ฅผ ๋ค์ด, 2 5 6์ 2๋ฒ ๋ฐ๊ตฌ๋๋ถํฐ 5๋ฒ ๋ฐ๊ตฌ๋๊น์ง์ 6๋ฒ ๊ณต์ ๋ฃ๋๋ค๋ ๋ป์ด๋ค. (1 โค i โค j โค N, 1 โค k โค N)
- ์ถ๋ ฅ
1๋ฒ ๋ฐ๊ตฌ๋๋ถํฐ N๋ฒ ๋ฐ๊ตฌ๋์ ๋ค์ด์๋ ๊ณต์ ๋ฒํธ๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค. ๊ณต์ด ๋ค์ด์์ง ์์ ๋ฐ๊ตฌ๋๋ 0์ ์ถ๋ ฅํ๋ค.
- ์์
ย ย ์ ๋ ฅย ย | ย ย ์ถ๋ ฅย ย |
---|---|
5 4 1 2 3 3 4 4 1 4 1 2 2 2 |
1 2 1 1 0 |
๐ 2. ํ์ด
2-0. ์๊ณ ๋ฆฌ์ฆ
1๋ฒ ๋ฐ๊ตฌ๋๋ถํฐ N๋ฒ ๋ฐ๊ตฌ๋๊น์ง ์์๋๋ก ๋ฐ๊ตฌ๋์ ๋ค์ด์๋ ๊ณต์ ๋ฒํธ๋ฅผ ์ถ๋ ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์,
๋ฐฐ์ด์ ์ฌ์ฉํด ๊ณต์ ๋ฒํธ๋ฅผ ์ ์ฅํ๋ค.
๋ฐฐ์ด์ ์ธ๋ฑ์ค 0๋ถํฐ ์์ํ๊ธฐ ๋๋ฌธ์ 1๋ฒ ๋ฐ๊ตฌ๋ ๊ณต์ ์ธ๋ฑ์ค 0์, 2๋ฒ ๋ฐ๊ตฌ๋ ๊ณต์ ์ธ๋ฑ์ค 1์,
N๋ฒ ๋ฐ๊ตฌ๋ ๊ณต์ ์ธ๋ฑ์ค N-1์ ์ ์ฅํ๋ฉด ๋๋ค.
๋ฐ๋ผ์, for ๋ฌธ์ ์ฌ์ฉํด ์ธ๋ฑ์ค i-1 ๋ถํฐ j-1 ๊น์ง์ ๊ฐ์ k๋ฅผ ์ ์ฅํ๋ค.
int[] arr = new int[N];
for(int b=i-1;b<j;b++) {
arr[b] = k;
}
2๊ฐ์ ์
๋ ฅ๋ฐฉ์๊ณผ 3๊ฐ์ ์ถ๋ ฅ๋ฐฉ์์ ์ฌ์ฉํด์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
- Scanner ํด๋์ค
- BufferedReader ํด๋์ค
2-1. Scanner ํด๋์ค
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int[] arr = new int[N];
for(int a=0;a<M;a++) {
int i = sc.nextInt();
int j = sc.nextInt();
int k = sc.nextInt();
for(int b=i-1;b<j;b++) {
arr[b] = k;
}
}
for(int num : arr) {
System.out.print(num + " ");
}
}
}
์์๊ฐ์ด ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋, Scanner(System.in) ์์
System.in
์ ์ ๋ ฅํ ๊ฐ์Byte ๋จ์
๋ก ์ฝ๋ ๊ฒ์ ๋ปํ๋ค.
intํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ๊ธฐ ์ํด
nextInt()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
ํ์ฅ for ๋ฌธ
์ ์ฌ์ฉํด ๋ฐฐ์ด์ ๊ฐ์ ๋ชจ๋ ์ถ๋ ฅํ๋ค.
[์ฌ๊ธฐ์ ์ ๊น!]
2-2. BufferedReader ํด๋์ค ์ฌ์ฉ
3๊ฐ์ง ์ถ๋ ฅ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๊ณ ๋น๊ตํด๋ณด์.
ย ย ย ย โ System.out.println()
ย ย ย ย โก BufferedWriter
ย ย ย ย โข StringBuilder
โ BufferedReader + System.out.println()
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.IOException;
public class Main {
public static void main(String args[]) throws IOException {
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken());
int M = Integer.parseInt(st.nextToken());
int[] arr = new int[N];
for(int a=0;a<M;a++) {
st = new StringTokenizer(br.readLine());
int i = Integer.parseInt(st.nextToken());
int j = Integer.parseInt(st.nextToken());
int k = Integer.parseInt(st.nextToken());
for(int b=i-1;b<j;b++) {
arr[b] = k;
}
}
for(int num : arr) {
System.out.print(num + " ");
}
br.close();
}
}
StringTokenizer ํด๋์ค
๋ฅผ ์ฌ์ฉํด โ โ (๊ณต๋ฐฑ)์ ๊ธฐ์ค์ผ๋ก ๊ฐ์ ๊ตฌ๋ถํ๊ณ ,nextToken()
๋ฅผ ์ฌ์ฉํด ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋ ์ ๋ ฅ๊ฐ๋ค์ ์์๋๋ก ๊ฐ์ ธ์จ๋ค.
Integer.parseInt()
์ ์ฌ์ฉํด Stringํ์intํ์ผ๋ก ๋ณํ
์์ผ์ค๋ค.
โก BufferedReader + BufferedWriter
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.util.StringTokenizer;
public class Main{
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken());
int M = Integer.parseInt(st.nextToken());
int[] arr = new int[N];
for(int a=0;a<M;a++) {
st = new StringTokenizer(br.readLine());
int i = Integer.parseInt(st.nextToken());
int j = Integer.parseInt(st.nextToken());
int k = Integer.parseInt(st.nextToken());
for(int b=i-1;b<j;b++) {
arr[b] = k;
}
}
for(int num : arr) {
bw.write(num + " ");
}
br.close();
bw.flush();
bw.close();
}
}
BufferedWriter ํด๋์ค์ write() ๋ฉ์๋
๋ ๋ฐ์ดํฐ๋ฅผ ๋ด๋ถ ๋ฒํผ์ ์ ์ฅํ๊ณ ,flush() ๋ฉ์๋
๋ฅผ ์ฌ์ฉํด ๋ฒํผ๋ฅผ ๋น์ฐ๊ณ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ๋ค.
BufferedWriter ํด๋์ค์ write() ๋ฉ์๋
๋ ๋จ๋ ์ผ๋ก int ํ ๊ฐ๋ง ๋ฃ์ ๊ฒฝ์ฐ ์์คํค ์ฝ๋๊ฐ์ผ๋ก ์ธ์๋๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ๋ฌธ์๊ฐ ์ถ๋ ฅ๋๋ค. ๋๋ฌธ์๋ฐ๋์ ๋ฌธ์์ด๊ณผ int ํ์ ํจ๊ป ๋ฃ์ด์ค์ผ
int ๊ฐ์ ์ ๋๋ก ์ถ๋ ฅํ ์ ์๋ค.
[์ฌ๊ธฐ์ ์ ๊น!]
BufferedReader๏ผBufferedWriter ํด๋์ค
์ ๋ํด ๋ ์์๋ณด๊ณ ์ถ์ผ๋ฉด ์ฌ๊ธฐ๋ฅผ ํด๋ฆญํ๋ฉด ๋๋ค.โข BufferedReader + StringBuilder
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;
public class Main{
public static void main(String[] args)throws IOException{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
StringBuilder sb = new StringBuilder();
int N = Integer.parseInt(st.nextToken());
int M = Integer.parseInt(st.nextToken());
int[] arr = new int[N];
for(int a=0;a<M;a++) {
st = new StringTokenizer(br.readLine());
int i = Integer.parseInt(st.nextToken());
int j = Integer.parseInt(st.nextToken());
int k = Integer.parseInt(st.nextToken());
for(int b=i-1;b<j;b++) {
arr[b] = k;
}
}
for(int num : arr) {
sb.append(num).append(" ");
}
System.out.println(sb);
}
}
StringBuilder ํด๋์ค
๋ ๋ฌธ์์ด์ ๋์ ์ผ๋ก ์กฐ์ํ๊ธฐ ์ํ ํด๋์ค๋ก,append()
๋ฅผ ์ฌ์ฉํด ๋ฌธ์์ด์ ์ถ๊ฐํ์ฌ ์๋ก์ด ๋ฌธ์์ด์ ์์ฑํ๋ค.
append()
๋ฅผ ์์ ๊ฐ์ด ๋๋ ์ ์ฐ๋ฉด ํ์ ๋ณํ๊ณผ ๋ฌธ์์ด ์ฐ๊ฒฐ ์ฐ์ฐ์ด ์ถ๊ฐ์ ์ผ๋ก ๋ฐ์ํ์ง ์๊ณ StringBuilder์ ์ง์ ์ถ๊ฐํ๊ธฐ ๋๋ฌธ์ ๋ณด๋ค ๋ ํจ์จ์ ์ด๊ณ ๋น ๋ฅด๋ค.
๐ 3. ์ฑ๋ฅ ๋น๊ต
์์์ ๋ถํฐ ์์๋๋ก
BufferedReader + StringBuilder
BufferedReader + BufferedWriter
BufferedReader + System.out.println()
Scanner
์์๊ฐ์ด ์
๋ ฅ ๋ฉ์๋์ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ ๋ฐฉ๋ฒ์ ๋ฐ๋ผ ์๊ฐ์ด ๋ฌ๋ผ์ง ์ ์๋ค.
์
๋ ฅ์ ๊ฒฝ์ฐ ํ์คํ Scanner ๋ณด๋ค๋ BufferedReader ๊ฐ ๋น ๋ฅธ ๊ฒ์ ๋ณผ ์ ์๋ค.
์ถ๋ ฅ์ ๊ฒฝ์ฐ StringBuilder ๊ฐ ์ ์ผ ๋น ๋ฅด๋ค.
BufferedWriter๋ ์ผ๋ฐ์ ์ผ๋ก I/O ์์
์ผ๋ก ์ธํด ๋น๊ต์ ๋๋ฆด ์ ์๋ค.
๋ฐ๋ฉด์ StringBuilder๋ ๋ฌธ์์ด ์กฐ์์ ์ต์ ํ๋ ํด๋์ค๋ก, ๋ฌธ์์ด ์ฐ์ฐ์ ์ผ๋ฐ์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ์์์ ์ํ๋๋ฏ๋ก ์๋์ ์ผ๋ก ๋น ๋ฅผ ์ ์๋ค.
๊ด๋ จ ํ์ด์ง
Leave a comment