๋ฌธ์ :
https://leetcode.com/problems/minimum-window-substring/
๋์ด๋ : hard
ํ์ด ์๊ณ ๋ฆฌ์ฆ : sliding window(์ฌ๋ผ์ด๋ฉ ์๋์ฐ)
โญ๏ธ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ ?
์ผ์ ๋ฒ์ ๋งํผ์ ์๋์ฐ(w)๋ฅผ ๊ฐ์ง๊ณ ์ฌ๋ผ์ด๋ฉ ~ ํ๋ฉฐ ์ฐพ๋ ๊ธฐ๋ฒ์ ๋งํฉ๋๋ค.
์ฃผ๋ก ๊ตฌ๊ฐ ๋ฌธ์ ์ ๋ง์ด ์ฌ์ฉ๋๋ฉฐ ํฌํฌ์ธํฐ์ ๋ฐฉ๋ฒ๋ก ์ด ๋น์ทํ์ฌ ๊ฐ์ด ์๊ธฐ ๋ฉ๋๋ค.
ํ์ง๋ง ํฌํฌ์ธํฐ๋ 2๊ฐ์ ํฌ์ธํฐ(left, right)๋ฅผ ๊ฐ์ง๊ณ ๊ตฌ๊ฐ์ ๊ธธ์ด๊ฐ ๋ค์ด๋๋ฏนํ๊ฒ ์์ง์ผ ์ ์์ง๋ง ์ฌ๋ผ์ด๋ฉ ์๋์ฐ์ ๊ฒฝ์ฐ ์๋ธ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ํญ์ ์ผ์ ํ๋ค๋ ์ ์์ ๋ค๋ฅธ ๋งค๋ ฅ์ ์ ๊ฐ์ง๋๋ค.
๋ฐ๋ก ๋ฐ๋ก
๐จ๐จ๐จ ์๋์ฐ์ ๊ธธ์ด๊ฐ w = 3 ๋งํผ ๊ณ ์ ๋์ด ๊ฐ๋ค ํ์ ๋
โฌ๏ธโฌ๏ธ๐จ๐จ๐จโฌ๏ธโฌ๏ธโฌ๏ธ -> โฌ๏ธโฌ๏ธ๐ฅ๐จ๐จ๐ฉโฌ๏ธโฌ๏ธ
์๋ก์ด ์๋ธ ๋ฐฐ์ด์ ๐จ๐จ๐ฉ ๊ฐ ๋ ๊ฒ์ ๋๋ค.
์ด๋ ๐จ๐จ๋ ์ค๋ณต ์ฌ์ฉ๋๋ฏ๋ก w-1 ๋งํผ์ ์ฌ์ฌ์ฉ ํ๋ฉฐ ๐ฉ์ ๋ํ๊ณ ๐ฅ๋ ๋นผ์ฃผ๋ฉฐ O(1)์๊ฐ๋งํผ ์๋ก์ด ๐จ๐จ๐ฉ ๊ฐ์ ๊ตฌํ ์ ์์ต๋๋ค.
๊ทธ๋์ ์๋ธ ์คํธ๋ง์ด ๊ตฌ๊ฐ์ ๋๋๋ฐ O(n) ๋งํผ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋๋ค.
๋ฌธ์ ๋ฅผ ์ค์ค๋ก ํ์ง ๋ชปํ๊ณ ์ข์ ๊ธฐ๋ฒ์ธ๊ฑฐ ๊ฐ์์ ๋ค์์ ์ ์ด์ฉํ๋ ค๊ณ ๋ฉ๋ชจํฉ๋๋ค ...
s_len๋งํผ ๋๋ฉด์ letters[s[high]]๊ฐ 0๋ณด๋ค ํฐ ๊ฐ๋ง count๋ฅผ ์ฆ๊ฐ์์ผ ๊ตฌ๊ฐ์ ๊ธธ์ด๋ฅผ ์ ํ๋ค.
high - low ๊ตฌ๊ฐ ๊ธธ์ด ๋งํผ์ ์๋ธ ๋ฐฐ์ด์ t ๋ฌธ์๋ค์ด ๋ค ํฌํจ๋์์ ์ low๊ฐ์ ์์ผ๋ก ์ฎ๊ฒจ ์ต์ํ์ ๊ธธ์ด๋ก ์ค์ด๊ณ min_length์ ์ ์ฅํ๋ค. low๋ฅผ ์ฎ๊ธธ ์ ์๋ ์กฐ๊ฑด์ letters map์ ๊ฐ์ด 0๋ณด๋ค ์์ ๊ฒฝ์ฐ!
t์ ์๋ ๋ฌธ์๋ค์ ์ด๊ธฐ ๊ฐ์ด 0์ด์๊ธฐ ๋๋ฌธ์ count ๊ฐ์ด t ๊ธธ์ด์ ๊ฐ์์ง๊ธฐ ์ ์ ์ด๋ฏธ ํ๋์ฉ ์ค์ด๋ค์๊ธฐ ๋๋ฌธ์ ๋ฌด์กฐ๊ถ -1, -2 ๋ฑ ์๊ด ์์ด 0๋ณด๋ค ์์ ๊ฐ์ผ ๊ฒ
t ๋ฌธ์ ์ค ์๋ธ ๋ฐฐ์ด์ ์ค๋ณต๋ ๋ฌธ์๊ฐ ์์ ๊ฒฝ์ฐ๋ ๋ง์ฐฌ๊ฐ์ง๋ก window์ ๋ฒ์์์ ์ค์ฌ์ผ ํ๋๋ฐ ์ค๋ณต๋ ๊ฐ์ t์ ์๋ ๋ฌธ์์ฒ๋ผ ๊ฐ์ด < 0 ์ผ๋ก ๋ง๋ค์ด์ง๊ธฐ ๋๋ฌธ์ window์ ์ ๋๊ฐ์ t ๋ฌธ์์ด์ด ์๋ ์ต์ํ์ window substring์ ๋ง๋ค ์ ์๋ค.
c++ ์ฝ๋ :
class Solution {
public:
string minWindow(string s, string t) {
int t_len = t.length();
int s_len = s.length();
int maxInt = 2147483647;
unordered_map<char, int> letters; // t ๋ฌธ์๊ฐ s์ ์๋์ง ํ์ธํ๊ธฐ ์ํ map ex> A : 1, B : -1, C : -2 ...
for(int i =0; i < t_len; i++){
letters[t[i]]++;
}
int count = 0; //t ๋ฌธ์์ด ์๋ธ ๋ฐฐ์ด์ ์ถฉ์กฑ ์
int low = 0, min_length = maxInt, min_start = 0;
for(int high = 0; high < s_len; high++) {
if(letters[s[high]] > 0) {
count++; //means that this letter is in t
}
letters[s[high]]--;
if(count == t_len) { //์กฐ๊ฑด ์ถฉ์กฑ
while(low < high && letters[s[low]] < 0) {
cout << letters[s[low]] <<'\n';
letters[s[low]]++;
low++;
}
if(maxInt > high-low) {
min_length = high - (min_start = low) + 1;
}
letters[s[low++]]++; //low ์
๋ฐ์ดํธ ์ ๋ฌธ์ ๊ฐ ์ฆ๊ฐ
count--;
}
}
return min_length == maxInt ? "" : s.substr(min_start, min_length);
}
};
์ ์ ์คํฐ๋ ์ธ๋๊ฐ ์นด์นด์ค ๋ณด์ ์ผํ ๋ฌธ์ ๋ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ฅผ ์ฌ์ฉํด ํ๋ฉด ์ข์ ๋ฌธ์ ๋ผ ์๋ ค์คฌ๋๋ฐ ํจ ํ์ด๋ด์ผ๊ฒ ๋ค.
'Algorithm๐ฐ > ๋ฆฌํธ์ฝ๋' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฆฌํธ์ฝ๋] 238. Product of Array Except Self (0) | 2021.12.10 |
---|---|
[๋ฆฌํธ์ฝ๋] 98. Validate Binary Search Tree - BT (0) | 2021.08.17 |
[๋ฆฌํธ์ฝ๋] 3. Longest Substring Without Repeating Characters (0) | 2021.07.16 |
[๋ฆฌํธ์ฝ๋] 1. Two Sum (๋์์ ํฉ) (0) | 2021.07.12 |
๋๊ธ