
์ด ํฌ์คํ ์ ์ฟ ํก ํํธ๋์ค ํ๋์ ์ผํ์ผ๋ก, ์ด์ ๋ฐ๋ฅธ ์ผ์ ์ก์ ์์๋ฃ๋ฅผ ์ ๊ณต๋ฐ์ต๋๋ค.
# 13 ์ฐ๊ฒฐ ์์์ ๊ฐ์ ๊ตฌํ๊ธฐ
์ฐ๊ฒฐ์์๋ ์์ง๋ก ์ฐ๊ฒฐ๋ ๋ ธ๋์ ์งํฉ
ex) 1, 2, 5์ 3, 4, 6 ์ด 2๊ฐ
DFS๋ ๊ทธ๋ํ ์์ ํ์์ด๋ฏ๋ก, ํ๋ฒ์ DFS๊ฐ ๋๋ ๋ ๊น์ง ํ์ํ ๋ ธ๋์ ์งํฉ์ด ์ฐ๊ฒฐ์์ 1๊ฐ์ด๋ค.
์ฆ ๋ชจ๋ ๋ ธ๋๋ฅผ ํ์ํ ๋์ DFS ํ์๊ฐ ์ฐ๊ฒฐ์์์ ๊ฐ์์ด๋ค.
๋ง์ฝ ๊ทธ๋ํ์ ๋ชจ๋ ๋ ธ๋๊ฐ ์ฐ๊ฒฐ ๋์ด ์์๋ค๋ฉด DFS ํ์๋ 1์ด๋ค.
๋ฐฉํฅ์ด ์๋ ๊ทธ๋ํ์ด๋ฏ๋ก ์๋ฐฉํฅ ๋ชจ๋ ์ธ์ ๋ฆฌ์คํธ๋ก ํํ
N=1,000์ด๋ฏ๋ก O(n^2)์ธ ์๊ณ ๋ฆฌ์ฆ๋ ์ฌ์ฉ๊ฐ๋ฅํ๋ค.
if(๋ฐฉ๋ฌธํ์ง ์์ ๋ ธ๋๊ฐ ์กด์ฌํ๋ค๋ฉด) { // ๊ฐ ์ฐ๊ฒฐ์์์ ๋ฐฉ๋ฌธ ์ฌ๋ถ
count++;
DFS(i);
}
DFS(int i) {
if(visited[i] == true) { // ์ฐ๊ฒฐ์์ ๋ด๋ถ์ ๋ ธ๋ ๋ฐฉ๋ฌธ ์ฌ๋ถ
return; // DFS() ํ์ฌ ๋ ธ๋ ํ์ ์ข ๋ฃ
}
}
#14 ๋ฏธ๋ก ํ์ํ๊ธฐ
์๋ก ์ธ์ ํ ์นธ๋ง ์ด๋ // ์ฆ, ์ํ์ข์ฐ 4๋ฐฉํฅ๋ง ์ด๋๊ฐ๋ฅ
dx, dy // ์ํ์ข์ฐ ์ด๋ ๋ฐฉํฅ ํํ ๋ฐฐ์ด
ex) 0 1 ์ด๋ฉด ์๋๋ก ์ด๋
(1, 1) ์์ ์ถ๋ฐ // ์ธ๋ฑ์ค ์ฃผ์
N=100์ด๋ฏ๋ก O(n^2)์ธ ์๊ณ ๋ฆฌ์ฆ๋ ์ฌ์ฉ๊ฐ๋ฅํ๋ค.
์ต๋จ๊ฒฝ๋ก ์ฐพ๊ธฐ ์ด๋ฏ๋ก DFS๋ ๊ฐ๋ฅํ์ง๋ง, BFS๊ฐ ๋ ์ ์ ํ๋ค. // ์ฌ๊ทํจ์๊ฐ ๋ฌ๊ณ ์์ด์ผ ํ๋ฏ๋ก
1๋์ ํ์ ๊ธฐ๋กํ๋ฉด (1,1)์์ ์๊ธฐ์์ ์ ๋๋ฌํ๋ ์ต๋จ ๊ฑฐ๋ฆฌ // ํ์ฉ๊ฐ๋ฅ
Queue ๋ LinkedList๋ก ๊ตฌํ
BFS(0,0) // ์ต๋จ ๊ฒฝ๋ก ํ์ ์คํ
for(์ํ์ข์ฐ ํ์) {
if(์ ํจํ ์ขํ) {
if(0์ด ์๋๋ฉด์ ์ด๋ฏธ ๋ฐฉ๋ฌธํ ๋ ธ๋X) {
}
}
}
๊ณต๋ฐฑ ์๋ ๋ฌธ์์ด ๋ถ๋ฆฌ substring(j, j+1);
#15 ์ํ๋ ์ ์ ์ฐพ๊ธฐ
N๊ฐ์ ์ ์ ์์ X๋ผ๋ ์ ์๊ฐ ์กด์ฌ ์ฌ๋ถ
N = 10,000 // ๋ฐ์ดํฐ ์ ์ ํฌ๊ธฐ(๊ฐ์)
M = 10,000 // ์ง์์ ๊ฐ์
์ด๋ฏ๋ก N^2์ธ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ง ๋ชปํ๋ค. ์๊ฐ๋ณต์ก๋๋ฅผ ๋ ์ค์ฌ์ผํ๋ค.
๊ทธ๋ฌ๋ฏ๋ก ์ด์งํ์ ์ฌ์ฉํ์ฌ ์ ๋ ฌ NlogN ๋จผ์ ํ, ํ์ logN์ ์ง์ M๋ฒ ์ํ
Arrays.sort(A);// ๋ฐฐ์ด A๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ, ์๊ฐ๋ณต์ก๋ O(nlogn)
while(์์ ์ธ๋ฐ์ค<=์ข ๋ฃ ์ธ๋ฑ์ค) // ๋ ์ด์ ํ์ํ ๋ถ๋ถ์ด ์์ ๋ ๊น์ง, ์ฆ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํ์ํ ๋๊น์ง ๋ฐ๋ณต
if(์ค์๊ฐ > ๋ฐ์ดํฐ) { // ์ผ์ชฝ ์ ํ
์ข ๋ฃ์ธ๋ฑ์ค = ์ค์์ธ๋ฑ์ค - 1
}
else if(์ค์๊ฐ< ๋ฐ์ดํฐ) { // ์ค๋ฅธ์ชฝ ์ ํ
์์์ธ๋ฑ์ค = ์ค์์ธ๋ฑ์ค + 1
}
else { // ์ค์๊ฐ == ๋ฐ์ดํฐ, ์ฆ ์ฐพ์์ผ๋ฏ๋ก
find = true;
break; // ๋ฐ๋ณต๋ฌธ ์ข ๋ฃ
}