์ซ์ ์นด๋๋ ์ ์ ํ๋๊ฐ ์ ํ์ ธ ์๋ ์นด๋์ด๋ค. ์๊ทผ์ด๋ ์ซ์ ์นด๋ N๊ฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ์ ์ M๊ฐ๊ฐ ์ฃผ์ด์ก์ ๋, ์ด ์๊ฐ ์ ํ์๋ ์ซ์ ์นด๋๋ฅผ ์๊ทผ์ด๊ฐ ๊ฐ์ง๊ณ ์๋์ง ์๋์ง๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ฒซ์งธ ์ค์ ์๊ทผ์ด๊ฐ ๊ฐ์ง๊ณ ์๋ ์ซ์ ์นด๋์ ๊ฐ์ N(1 โค N โค 500,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ ์ซ์ ์นด๋์ ์ ํ์๋ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ซ์ ์นด๋์ ์ ํ์๋ ์๋ -10,000,000๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค. ๋ ์ซ์ ์นด๋์ ๊ฐ์ ์๊ฐ ์ ํ์๋ ๊ฒฝ์ฐ๋ ์๋ค.
์ ์งธ ์ค์๋ M(1 โค M โค 500,000)์ด ์ฃผ์ด์ง๋ค. ๋ท์งธ ์ค์๋ ์๊ทผ์ด๊ฐ ๊ฐ์ง๊ณ ์๋ ์ซ์ ์นด๋์ธ์ง ์๋์ง๋ฅผ ๊ตฌํด์ผ ํ M๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ฉฐ, ์ด ์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด์ ธ ์๋ค. ์ด ์๋ -10,000,000๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค
์ฒซ์งธ ์ค์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง M๊ฐ์ ์์ ๋ํด์, ๊ฐ ์๊ฐ ์ ํ ์ซ์ ์นด๋๋ฅผ ์๊ทผ์ด๊ฐ ๊ฐ์ง๊ณ ์์ผ๋ฉด 1์, ์๋๋ฉด 0์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค.
5
6 3 2 10 -10
8
10 9 -5 2 3 4 5 -10
1 0 0 1 1 0 0 1
import java.util.*;
public class Baekjoon_10815 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> N_list = new ArrayList<>();
ArrayList<Integer> M_list = new ArrayList<>();
// ์๊ทผ์ด์ ์นด๋ ์
๋ ฅ
int N = sc.nextInt();
for (int i = 0; i < N; i++) {
N_list.add(sc.nextInt());
}
// ๋น๊ตํ ์นด๋ ์
๋ ฅ
int M = sc.nextInt();
for (int i = 0; i < M; i++) {
M_list.add(sc.nextInt());
}
// ์๊ทผ์ด์ ์นด๋์ ์กด์ฌํ๋ ์ง ํ๋์ฉ ํ์ธ
for (int i = 0; i < M; i++) {
if (N_list.contains(M_list.get(i))) {
System.out.print(1 + " ");
}
else {
System.out.print(0 + " ");
}
}
System.out.print("\b"); // ๋ง์ง๋ง ๊ณต๋ฐฑ ์ ๊ฑฐ
sc.close();
}
}
๋๋ ๋จ์ํ ๋น๊ตํ ์นด๋์ ์๊ทผ์ด์ ์นด๋๋ฅผ ๋น๊ตํ๊ธฐ๋ง ํ๋ฉด ๋๋ค๊ณ ์๊ฐํด, ๋ ๊ฐ์ ArrayList๋ฅผ ๋ง๋ค์ด์ contains
ํจ์๋ฅผ ํตํด ํด๋น ์นด๋๊ฐ ์๊ทผ์ด์ ์นด๋๋ฅผ ๋ด๊ณ ์๋ ArrayList์ ์กด์ฌํ๋ ์ง ์ฌ๋ถ๋ฅผ ํ๋ณํ๋๋ก ๊ตฌํํ์๋ค.
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋์ผํ์ผ๋, ๊ฒฐ๊ณผ๋ ์๊ฐ ์ด๊ณผ๋ก ์ธํด ์คํจ์๋ค.
๊ทธ๋ ๋ค๋ฉด ์๊ฐ์ ๋จ์ถ์ํฌ ์ ์๋ ๋ฐฉ๋ฒ์๋ ๋ฌด์์ด ์์๊น ๊ฐ๋งํ ์๊ฐํด ๋ณด์๋ค.
์์ธ์ด ๋ญ๊ฐ ArrayList์ contains()
๋ฉ์๋ ์ผ ๊ฒ์ด๋ผ๋ ์๊ฐ์ด ๋ค์๋ค.
๊ทธ๋์ ๊ฒ์์ ํด๋ณด๋, ArrayList์์ contains()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด, ๋ฆฌ์คํธ์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉด์ ํน์ ์์๊ฐ ์กด์ฌํ๋ ์ง ํ์ธํ๋ ๊ณผ์ ์ ๊ฑฐ์น๊ธฐ ๋๋ฌธ์, ์ต์
์ ๊ฒฝ์ฐ ์ ์๊ฐ์ด ์์ ๋๋ค๋ ์ฌ์ค์ ๊นจ๋ฌ์๋ค.
๊ฒ๋ค๊ฐ ์ด๊ฑธ M
๋งํผ ๋ฐ๋ณตํ๋๋ก ์ฝ๋๋ฅผ ๊ตฌ์ฑํด ๋์์ผ๋, ์ด๋ผ๋ ๋นํจ์จ์ ์ธ ์คํ ์๊ฐ์ ์ด๋ํ๋ ๊ฒ์ด๋ค.
๊ทธ๋์ ๋๋ ArrayList๋์ Set์ ์ฌ์ฉํด ๋ฌธ์ ๋ฅผ ๋ค์ ํ์๋ค.
Set ์ค์์๋ Hash Set์ Hash table์ ๊ธฐ๋ฐ์ผ๋ก ์๋ํ๋ Set์ด๊ธฐ ๋๋ฌธ์, ๊ฒ์ํ๋ ์์
์ ์ํํ๋ ๋ฐ ์์ ์๊ฐ๋ฐ์ ์์๋์ง ์๋๋ค๋ ์ฅ์ ์ด ์๋ค!
import java.util.*;
public class Baekjoon_10815 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Set<Integer> N_set = new HashSet<>(); // Hash Set
StringBuilder result = new StringBuilder();
// ์๊ทผ์ด์ ์นด๋ ์
๋ ฅ
int N = sc.nextInt();
for (int i = 0; i < N; i++) {
N_set.add(sc.nextInt());
}
// ๋น๊ตํ ์นด๋ ์
๋ ฅ
int M = sc.nextInt();
for (int i = 0; i < M; i++) {
if (N_set.contains(sc.nextInt())) {
result.append(1).append(" ");
}
else {
result.append(0).append(" ");
}
}
result.toString().trim(); // ๋ง์ง๋ง ๊ณต๋ฐฑ ์ ๊ฑฐ
System.out.print(result);
sc.close();
}
}
์ด๋ ๊ฒ ArrayList๋์ Hash Set์ ์ฌ์ฉํจ์ผ๋ก์จ ์คํ ์๊ฐ์ ๋จ์ถ์ํฌ ์ ์์๋ค!
์ค๋๋ ๋ฉ์๋ค๊ตฌ!๐