๐๊ณต๋ถํ ๊ฑฐ List๐
- ์ฝ๋ฉ์ธํฐ๋ทฐ์์ ๋ถ์ - ํธ๋ฆฌ์ ๊ทธ๋ํ ์ด๋ก ์ ๋ฆฌ
- ์ข ๋ง๋ถ - 21. ํธ๋ฆฌ์ ๊ตฌํ๊ณผ ์ํ ('์์' ์ ์ธ)
- ์ข ๋ง๋ถ - 22. ์ด์ง๊ฒ์ํธ๋ฆฌ ('ํธ๋ฆฝ', '์ฝ์ ์ ๋ ฌ ๋ค์ง๊ธฐ' ์ ์ธ)
- ์ข ๋ง๋ถ - 27. ๊ทธ๋ํ์ ํํ๊ณผ ์ ์
- ์ข ๋ง๋ถ - 28. ๊ทธ๋ํ์ ๊น์ด ์ฐ์ ํ์
struct TreeNode {
string label; //value
TreeNode* parent;
vector<TreeNode*> children;
};
- ๋ชจ๋ ๋ ธ๋๋ฅผ ์ํํ๋ฉฐ ๋ฐ์ดํฐ ์ถ๋ ฅ
- ํธ๋ฆฌ์ ๋์ด๊ตฌํ๊ธฐ(height(tree) = max(depths(subtree)))
- ์ํ ์ข
๋ฅ :
pre-order
(VLR),in-order
(LVR),post-order
(LRV)
void printLables(TreeNode* root) {
cout << root->label << endl;
for(int i=0; i<root->children.size(); ++i) {
printLables(root->children);
}
}
int height(TreeNode* root) {
int h=0;
for(int i=0; i<root->children.size(); ++i) {//๋ฃจํธ์ ์์ ์๋งํผ
//root->children[i] : ๋ฃจํธ์ i๋ฒ์งธ ์์
h = max(h, 1 + height(root->children[i]));
}
return h;
}
๋ฌธ์ : ์ ์์ํํ์ ๋ ๋ ธ๋๋ฐฉ๋ฌธ์์(preorder)์ ์ค์์ํํ์ ๋ ๋ ธ๋๋ฐฉ๋ฌธ์์(inorder)๊ฐ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ก์ ๋, ์ด ํธ๋ฆฌ๋ฅผ ํ์์ํํ์ ๋ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธ์์๋ฅผ ์ถ๋ ฅ.
โก๏ธkeypointโก๏ธ
- ์ ์์ํ ์, ์ฒ์์ผ๋ก ๋ฐฉ๋ฌธํ๋ ๋ ธ๋๊ฐ ๊ทธ ํธ๋ฆฌ์ ๋ฃจํธ๋ ธ๋์ด๋ค.
- ์ค์์ํ ์, ๋ฃจํธ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ์ด์ ์ ๋ฐฉ๋ฌธํ ๋ ธ๋๋ค์ ๋ฃจํธ๋ณด๋ค ์์ ๊ฐ์ ๊ฐ์ง๋ฉฐ, ์ดํ์ ๋ฐฉ๋ฌธํ ๋ ธ๋๋ค์ ๋ฃจํธ๋ณด๋ค ํฐ ๊ฐ์ ๊ฐ์ง๋ค.
- ๊ทธ๋ฌ๋ฏ๋ก preorder[0]์ด rootnode์์ ์ ์ฅํ๊ณ , inorder์์ rootnode์ ์์น๋ฅผ ์ฐพ์ ํ, ์ฌ๊ทํธ์ถ์ ์ด์ฉํด ํ์์ํ๋ฅผ ํ๋ฉด๋๋ค.
๐**ํด๋ต(์ฝ๋)**๐
/*
* ๋ฐฐ์ด v๋ฅผ ๊ตฌ๊ฐ [a,b]๋ก ์ชผ๊ฐ๋ ํจ์
* @param v [์ชผ๊ฐ๋ ค๋ ๋ฐฐ์ด(ํธ๋ฆฌ)]
* @param a [์์๊ตฌ๊ฐ]
* @param b [๋๊ตฌ๊ฐ]
*/
vector<int> slice(const vector<int>& v, int a, int b) {
return vector<int>(v.begin()+a, v.begin()+b);
}
void printPostOrder(const vector<int>& preorder, const vector<int>& inorder) {
const int N = preorder.size();
if(preorder.empty()) return;
const int root = preorder[0];
const int L = find(inorder.begin(), inorder.end(), root) - inorder.begin();
const int R = N - 1 - L;
printPostOrder(slice(preorder, 1, L+1), slice(inorder, 0, L));
printPostOrder(slice(preorder, L+1, N), slice(inorder, L+1, N));
cout<<root<<' ';
}
- ๊ฒ์ ํธ๋ฆฌ๋ ์๋ฃ๋ค์ ์ผ์ ํ ์์์ ๋ฐ๋ผ ์ ๋ ฌ๋ ์ํ๋ก ์ ์ฅํ๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์์์ ์ถ๊ฐ/์ญ์ ์ฐ์ฐ๊ณผ ํน์ ์์๋ฅผ ์ฐพ๋ ์ฐ์ฐ์ด ๋งค์ฐ ๋น ๋ฅด๊ฒ ๋์ํ๋ค.
- ์ด์งํธ๋ฆฌ์ ์ ์ : ์ต๋ ๋ ๊ฐ์ ์์๋ ธ๋๋ฅผ ๊ฐ๋ ํธ๋ฆฌ
- ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ์ค์ ์ํํ๋ฉด ํฌ๊ธฐ ์์๋ก ์ ๋ ฌ๋ ์์์ ๋ชฉ๋ก์ ์ป๋๋ค. ์ฆ, ์ต๋์์์ ์ต์์์๋ฅผ ์ฝ๊ฒ ์ป์ ์ ์๋ค. **์ค์์ํ ์ ๊ฐ์ฅ ์ฒซ๋ฒ์งธ๋ก ๋ฐฉ๋ฌธํ๋ ๋ ธ๋๋ ์ต์๊ฐ์, ๊ฐ์ฅ ๋ง์ง๋ง์ ๋ฐฉ๋ฌธํ๋ ๋ ธ๋๋ ์ต๋๊ฐ์ ๊ฐ๋๋ค. **
- ํธ๋ฆฝ(Treap) : ์ฃผ์ด์ง ๊ฐ X๋ณด๋ค ์์ ์์์ ์, ํน์ (ํฌ๊ธฐ์์ผ๋ก ์ ๋ ฌ๋์๋ค๊ณ ๊ฐ์ ) k-๋ฒ์งธ ์์๋ฅผ ์ฐพ๋ ์ฐ์ฐ๋ค์ ์ํํ๋๋ฐ ์ฌ์ฉํ๋ค.
- ๊ท ํ ์กํ ์ด์ง ๊ฒ์ ํธ๋ฆฌ(balanced BST) : ํธ๋ฆฌ์ ๋์ด๊ฐ ํญ์ **O(lgN)**์ด ๋๋๋ก ํ๋ ํธ๋ฆฌ. (ex. ๋ ๋-๋ธ๋ ํธ๋ฆฌ_Red-Black Tree)
๋ฌธ์ : ๋๋์ง์๋ฅผ ๊ณ์ฐํ๋ ๊ธฐ์ค์ 1. ํผ ๋ฌธ์ ์ ์/ 2. ์๋ฒฝ์ ๋จน์ ๋ผ๋ฉด๊ทธ๋ฆ์ ์ด๋ค. ๋ง์ฝ ํ ์ฐธ๊ฐ์๋ณด๋ค ํผ ๋ฌธ์ ์ ์๊ฐ ์ ๊ณ , ์๋ฒฝ์ ๋จน์ ๋ผ๋ฉด ๊ทธ๋ฆ ์๊ฐ ์ ๋ค๋ฉด ์ด ์ฌ๋์ ๋ํ์๊ฒฉ์ด ์๋ค๊ณ ํ๋จํ๋ค. ์ด ๋, ๊ฐ ์ฌ๋์ด ์ฐธ๊ฐ์ ์ฒญ์ ํ ๋๋ง๋ค ๋ํ์ ์ฐธ๊ฐํ ์ ์๋ ์ฌ๋๋ค์ ์๊ฐ ์ด๋ป๊ฒ ๋ณํ๋์ง ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ ์์ฑ.
โก๏ธkeypointโก๏ธ
- map<int, int>๋ฅผ ์ด์ฉํด ๊ท ํ์กํ BST๋ฅผ ๊ตฌํํ๋ค.
- lower_bound(x) ๋ x์ด์์ ๊ฐ ์ค ๊ฐ์ฅ ์์ ๊ฐ์ ๋ฐํํ๋ STL์ด๋ค.
- ๋ง์ฝ ์ ์ฐธ๊ฐ์์ x์ขํ(๋ฌธ์ ์)๊ฐ์ lower_bound๋ฅผ ๊ฐ์ง๋ ์ฐธ๊ฐ์ K๊ฐ ์ ์ฐธ๊ฐ์๋ฅผ ์ง๋ฐฐํ๋ค๋ฉด, ๊ทธ๋ณด๋ค ํฐ x์ขํ๋ฅผ ๊ฐ๋ ์ฐธ๊ฐ์์๋ ๋น๊ตํ ํ์๊ฐ ์๋ค. ์๋ํ๋ฉด ์ขํ์ ์ฐ์ธก์ผ๋ก ๊ฐ์๋ก y์ขํ๊ฐ์ ์์์ง๊ณ , x์ขํ๊ฐ์ ์ปค์ง๊ธฐ ๋๋ฌธ์ด๋ค.
๐**ํด๋ต(์ฝ๋)**๐
map<int,int> coords; //๊ฐ ์ฐธ๊ฐ์๋ค์ ๋ฐ์ดํฐ(x,y)
bool isDominated(int x, int y) {
map<int,int>::iterator it = coords.lower_bound(x);
if(it == coors.end()) return false;
return y < it->second;
}
void removeDominated(int x, int y) {
map<int,int>::iterator it = coords.lower_bound(x);
if(it == coords.begin()) return;
--it;
while(true) {
if(it->second > y) break;
if(it == coords.begin()) {
coords.erase(it);
break;
}
else {
map<int,int>::iterator jt = it;
--jt;
coords.erase(it);
it = jt;
}
}
}
int registered(int x, int y) {
if(isDominated(x,y)) return coords.size();
removeDominated(x,y);
coords[x] = y;
return coords.size();
}
โฑTime-Complexityโฑ
O(N lgN)