2023. 10. 23. 13:43ใ์ธํ๋ฐ/์๋ฐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด ์ ๋ฌธ : ์ฝ๋ฉํ ์คํธ ๋๋น
https://hyejin.tistory.com/1228
-> ์ด์ ๋ฌธ์ ํ์ด
3. ๋งค์ถ์ก์ ์ข ๋ฅ
์ค๋ช
ํ์์ ์๋น ๋ ์ ๊ณผ์ ์ ์ด์ํฉ๋๋ค. ํ์์๋น ๋ ํ์์๊ฒ N์ผ ๋์์ ๋งค์ถ๊ธฐ๋ก์ ์ฃผ๊ณ ์ฐ์๋ K์ผ ๋์์ ๋งค์ถ์ก์ ์ข ๋ฅ๋ฅผ
๊ฐ ๊ตฌ๊ฐ๋ณ๋ก ๊ตฌํ๋ผ๊ณ ํ์ต๋๋ค.
๋ง์ฝ N=7์ด๊ณ 7์ผ ๊ฐ์ ๋งค์ถ๊ธฐ๋ก์ด ์๋์ ๊ฐ๊ณ , ์ด๋ K=4์ด๋ฉด
20 12 20 10 23 17 10
๊ฐ ์ฐ์ 4์ผ๊ฐ์ ๊ตฌ๊ฐ์ ๋งค์ถ์ข ๋ฅ๋
์ฒซ ๋ฒ์งธ ๊ตฌ๊ฐ์ [20, 12, 20, 10]๋ ๋งค์ถ์ก์ ์ข ๋ฅ๊ฐ 20, 12, 10์ผ๋ก 3์ด๋ค.
๋ ๋ฒ์งธ ๊ตฌ๊ฐ์ [12, 20, 10, 23]๋ ๋งค์ถ์ก์ ์ข ๋ฅ๊ฐ 4์ด๋ค.
์ธ ๋ฒ์งธ ๊ตฌ๊ฐ์ [20, 10, 23, 17]๋ ๋งค์ถ์ก์ ์ข ๋ฅ๊ฐ 4์ด๋ค.
๋ค ๋ฒ์งธ ๊ตฌ๊ฐ์ [10, 23, 17, 10]๋ ๋งค์ถ์ก์ ์ข ๋ฅ๊ฐ 3์ด๋ค.
N์ผ๊ฐ์ ๋งค์ถ๊ธฐ๋ก๊ณผ ์ฐ์๊ตฌ๊ฐ์ ๊ธธ์ด K๊ฐ ์ฃผ์ด์ง๋ฉด ์ฒซ ๋ฒ์งธ ๊ตฌ๊ฐ๋ถํฐ ๊ฐ ๊ตฌ๊ฐ๋ณ
๋งค์ถ์ก์ ์ข ๋ฅ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
์ ๋ ฅ
์ฒซ ์ค์ N(5<=N<=100,000)๊ณผ K(2<=K<=N)๊ฐ ์ฃผ์ด์ง๋๋ค.
๋ ๋ฒ์งธ ์ค์ N๊ฐ์ ์ซ์์ด์ด ์ฃผ์ด์ง๋๋ค. ๊ฐ ์ซ์๋ 500์ดํ์ ์์ด ์๋ ์ ์์ ๋๋ค.
์ถ๋ ฅ
์ฒซ ์ค์ ๊ฐ ๊ตฌ๊ฐ์ ๋งค์ถ์ก ์ข ๋ฅ๋ฅผ ์์๋๋ก ์ถ๋ ฅํฉ๋๋ค.
์์ ์ ๋ ฅ 1
7 4
20 12 20 10 23 17 10
์์ ์ถ๋ ฅ 1
3 4 4 3
๋ฌธ์ ํ์ด 1
public ArrayList<Integer> solution(int n, int k, int[] arr)
{
ArrayList<Integer> answer = new ArrayList<>();
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < n; i++)
{
if (i < k)
{
map.put(arr[i], map.getOrDefault(arr[i], 0) + 1);
if (i == k - 1) {
answer.add(map.keySet().size());
}
}
else
{
map.put(arr[i - k], map.get(arr[i - k]) - 1);
if (map.get(arr[i - k]) == 0)
{
map.remove(arr[i - k]);
}
map.put(arr[i], map.getOrDefault(arr[i], 0) + 1);
answer.add(map.keySet().size());
}
}
return answer;
}
๐ฉ๐ป : ์ด๋ฒ ๋ฌธ์ ๋ Sliding Window๋ก ๋ฌธ์ ๋ฅผ ํธ๋๋ฐ ์ด๋ HashMap ์ ์ฌ์ฉํ๋ ๋ฐฉ์์ด์๋ค.
์ฐ์ i๊ฐ k-1 ๊น์ง ๋ ๋๋ HashMap์ ๊ธฐ๋ณธ ๊ฐ์ ์ธํ ํด์ฃผ๊ณ ์ด ํค ๊ฐ์ size๋ฅผ arrayList์ ๋ด์์คฌ๋ค. (์ฒซ๋ฒ์งธ ๊ตฌ๊ฐ์ ๋งค์ถ ์ข ๋ฅ)
๊ทธ ๋ค์ i - k ๋ฒ์งธ ๊ฐ์ ์ฒซ๋ฒ์งธ ๊ตฌ๊ฐ์์ ๋ฒ์ด๋๊ธฐ ๋๋ฌธ์ HashMap์์ ๊ทธ ๊ฐ์ ๋นผ์ฃผ๊ณ , ์ด๋ HashMap์์ arr[i-k]์ value ๊ฐ์ ๋บ๋๋ 0 ์ด ๋์์ ๊ฒฝ์ฐ์๋ key๊ฐ์ ์ ๊ฑฐํด์ค์ผ ํ๋ค. (์๊ทธ๋ฌ๋ฉด size ๊ฐ ๊ณ์ฐํ ๋ value๊ฐ 0 ์ธ ํค๊ฐ๋ ํฌํจ๋๊ธฐ ๋๋ฌธ!)
๊ทธ ๋ค์ ํ ์นธ ์์ผ๋ก ๊ฐ์ผํ๊ธฐ ๋๋ฌธ์ map์ arr[i] ํค ๊ฐ์ +1 ํด์ฃผ๊ณ , ๊ทธ ๋ค์ answer์ size๋ฅผ addํด์คฌ๋ค.
๋ฌธ์ ํ์ด 2
public ArrayList<Integer> solution2(int n, int k, int[] arr)
{
ArrayList<Integer> answer = new ArrayList<>();
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < k - 1; i++)
{
map.put(arr[i], map.getOrDefault(arr[i], 0) + 1);
}
int lt = 0;
for (int rt = k-1; rt < n; rt++)
{
map.put(arr[rt], map.getOrDefault(arr[rt], 0) + 1);
answer.add(map.size());
map.put(arr[lt], map.get(arr[lt]) - 1);
if (map.get(arr[lt]) == 0)
{
map.remove(arr[lt]);
}
lt++;
}
return answer;
}
๐พ : ๊ฐ์ฌ๋๋ ๋์ ๋น์ทํ๊ฒ ํ์๋๋ฐ ๊ฐ์ฌ๋์ ์ฐ์ k-1 ๊ฐ๋ง map์ ์ธํ ํด์ฃผ๊ณ lt, rt ๊ฐ์ ์ด์ฉํด์ ๊ฐ์ ๋ํ๊ณ ๊ณ์ฐํ๊ณ ํ๋ ๋ฐฉ์์ผ๋ก ํ์ด๋๊ฐ๋ค.
๋จผ์ ๋ฐ๋ณต๋ฌธ์ ํตํด์ HashMap์ k-1 ๋งํผ ๊ฐ์ ์ฐ์ ์ธํ ํด์ฃผ๊ณ ,
๊ทธ ๋ค์ ๋ฐ๋ณต๋ฌธ์์๋ rt๊ฐ k-1๋ถํฐ ์์ํด์ ์์ผ๋ก ์ด๋ํ๋๋ก ํ๋ค. ๊ทธ๋์ map์ arr[rt] ํค ๊ฐ์ ๊ตฌํ์ ๋ ์์ผ๋ฉด 0, ์๋๋ฉด ๊ทธ ๊ฐ์ ๊ฐ์ ธ์ + 1 ํด์ฃผ๊ณ , HashMap์ ์ฌ์ด์ฆ๋ฅผ answer์ add ํด์คฌ๋ค.
๊ทธ๋ฌ๊ณ ๋ค์ lt ๊ฐ์ ์์ง์ฌ์ HashMap์์ lt ํค ๊ฐ์ ๋ํ ๊ฐ์ -1 ํด์ฃผ๋๋ฐ ์ด๋ HashMap์ ๊ฐ์ด 0์ด๋๋ฉด HashMap์์ remove ํด์คฌ๋ค. (๊ทธ๋์ผ HashMap ์ฌ์ด์ฆ ๊ณ์ฐํ ๋ ํฌํจ ์ํจ !!)
๊ทธ ๋ค์ lt ๊ฐ์ +1 ์ฆ๊ฐํด์ฃผ๋ฉด ๊ฐ์ ๊ตฌํ ์ ์๋ค.