Skip to content

Latest commit

ย 

History

History
157 lines (123 loc) ยท 5.53 KB

0721-tree-graph.md

File metadata and controls

157 lines (123 loc) ยท 5.53 KB

2020.07.21 Tue

๐Ÿ“š๊ณต๋ถ€ํ•œ ๊ฑฐ List๐Ÿ“š

  • ์ฝ”๋”ฉ์ธํ„ฐ๋ทฐ์™„์ „๋ถ„์„ - ํŠธ๋ฆฌ์™€ ๊ทธ๋ž˜ํ”„ ์ด๋ก  ์ •๋ฆฌ
  • ์ข…๋งŒ๋ถ - 21. ํŠธ๋ฆฌ์˜ ๊ตฌํ˜„๊ณผ ์ˆœํšŒ ('์š”์ƒˆ' ์ œ์™ธ)
  • ์ข…๋งŒ๋ถ - 22. ์ด์ง„๊ฒ€์ƒ‰ํŠธ๋ฆฌ ('ํŠธ๋ฆฝ', '์‚ฝ์ž… ์ •๋ ฌ ๋’ค์ง‘๊ธฐ' ์ œ์™ธ)
  • ์ข…๋งŒ๋ถ - 27. ๊ทธ๋ž˜ํ”„์˜ ํ‘œํ˜„๊ณผ ์ •์˜
  • ์ข…๋งŒ๋ถ - 28. ๊ทธ๋ž˜ํ”„์˜ ๊นŠ์ด ์šฐ์„  ํƒ์ƒ‰

[์ข…๋งŒ๋ถ] ํŠธ๋ฆฌ์˜ ๊ตฌํ˜„๊ณผ ์ˆœํšŒ

โŒจ๏ธํŠธ๋ฆฌ์˜ ๋…ธ๋“œ๋ฅผ ํ‘œํ˜„ํ•˜๋Š” ๊ฐ์ฒด

struct TreeNode {
  string label; //value
  TreeNode* parent;
  vector<TreeNode*> children;
};

ํŠธ๋ฆฌ์˜ ์ˆœํšŒ(traversal)

  • ๋ชจ๋“  ๋…ธ๋“œ๋ฅผ ์ˆœํšŒํ•˜๋ฉฐ ๋ฐ์ดํ„ฐ ์ถœ๋ ฅ
  • ํŠธ๋ฆฌ์˜ ๋†’์ด๊ตฌํ•˜๊ธฐ(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;
}

๐Ÿ“์˜ˆ์ œ::ํŠธ๋ฆฌ ์ˆœํšŒ ์ˆœ์„œ ๋ณ€๊ฒฝ(ID: TRAVERSAL)

๋ฌธ์ œ : ์ „์œ„์ˆœํšŒํ–ˆ์„ ๋•Œ ๋…ธ๋“œ๋ฐฉ๋ฌธ์ˆœ์„œ(preorder)์™€ ์ค‘์œ„์ˆœํšŒํ–ˆ์„ ๋•Œ ๋…ธ๋“œ๋ฐฉ๋ฌธ์ˆœ์„œ(inorder)๊ฐ€ ์ž…๋ ฅ์œผ๋กœ ์ฃผ์–ด์กŒ์„ ๋•Œ, ์ด ํŠธ๋ฆฌ๋ฅผ ํ›„์œ„์ˆœํšŒํ–ˆ์„ ๋•Œ ๋…ธ๋“œ๋“ค์˜ ๋ฐฉ๋ฌธ์ˆœ์„œ๋ฅผ ์ถœ๋ ฅ.

โšก๏ธkeypointโšก๏ธ

  1. ์ „์œ„์ˆœํšŒ ์‹œ, ์ฒ˜์Œ์œผ๋กœ ๋ฐฉ๋ฌธํ•˜๋Š” ๋…ธ๋“œ๊ฐ€ ๊ทธ ํŠธ๋ฆฌ์˜ ๋ฃจํŠธ๋…ธ๋“œ์ด๋‹ค.
  2. ์ค‘์œ„์ˆœํšŒ ์‹œ, ๋ฃจํŠธ๋…ธ๋“œ๋ฅผ ๊ธฐ์ค€์œผ๋กœ ์ด์ „์— ๋ฐฉ๋ฌธํ•œ ๋…ธ๋“œ๋“ค์€ ๋ฃจํŠธ๋ณด๋‹ค ์ž‘์€ ๊ฐ’์„ ๊ฐ€์ง€๋ฉฐ, ์ดํ›„์— ๋ฐฉ๋ฌธํ•œ ๋…ธ๋“œ๋“ค์€ ๋ฃจํŠธ๋ณด๋‹ค ํฐ ๊ฐ’์„ ๊ฐ€์ง„๋‹ค.
  3. ๊ทธ๋Ÿฌ๋ฏ€๋กœ 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<<' ';
}

[์ข…๋งŒ๋ถ] ์ด์ง„ ๊ฒ€์ƒ‰ ํŠธ๋ฆฌ(BST)

  • ๊ฒ€์ƒ‰ ํŠธ๋ฆฌ๋Š” ์ž๋ฃŒ๋“ค์„ ์ผ์ •ํ•œ ์ˆœ์„œ์— ๋”ฐ๋ผ ์ •๋ ฌ๋œ ์ƒํƒœ๋กœ ์ €์žฅํ•œ๋‹ค. ๊ทธ๋ ‡๊ธฐ ๋•Œ๋ฌธ์— ์›์†Œ์˜ ์ถ”๊ฐ€/์‚ญ์ œ ์—ฐ์‚ฐ๊ณผ ํŠน์ •์›์†Œ๋ฅผ ์ฐพ๋Š” ์—ฐ์‚ฐ์ด ๋งค์šฐ ๋น ๋ฅด๊ฒŒ ๋™์ž‘ํ•œ๋‹ค.
  • ์ด์ง„ํŠธ๋ฆฌ์˜ ์ •์˜ : ์ตœ๋Œ€ ๋‘ ๊ฐœ์˜ ์ž์‹๋…ธ๋“œ๋ฅผ ๊ฐ–๋Š” ํŠธ๋ฆฌ
  • ์ด์ง„ ๊ฒ€์ƒ‰ ํŠธ๋ฆฌ๋ฅผ ์ค‘์œ„ ์ˆœํšŒํ•˜๋ฉด ํฌ๊ธฐ ์ˆœ์„œ๋กœ ์ •๋ ฌ๋œ ์›์†Œ์˜ ๋ชฉ๋ก์„ ์–ป๋Š”๋‹ค. ์ฆ‰, ์ตœ๋Œ€์›์†Œ์™€ ์ตœ์†Œ์›์†Œ๋ฅผ ์‰ฝ๊ฒŒ ์–ป์„ ์ˆ˜ ์žˆ๋‹ค. **์ค‘์œ„์ˆœํšŒ ์‹œ ๊ฐ€์žฅ ์ฒซ๋ฒˆ์งธ๋กœ ๋ฐฉ๋ฌธํ•˜๋Š” ๋…ธ๋“œ๋Š” ์ตœ์†Œ๊ฐ’์„, ๊ฐ€์žฅ ๋งˆ์ง€๋ง‰์— ๋ฐฉ๋ฌธํ•˜๋Š” ๋…ธ๋“œ๋Š” ์ตœ๋Œ€๊ฐ’์„ ๊ฐ–๋Š”๋‹ค. **
  • ํŠธ๋ฆฝ(Treap) : ์ฃผ์–ด์ง„ ๊ฐ’ X๋ณด๋‹ค ์ž‘์€ ์›์†Œ์˜ ์ˆ˜, ํ˜น์€ (ํฌ๊ธฐ์ˆœ์œผ๋กœ ์ •๋ ฌ๋˜์—ˆ๋‹ค๊ณ  ๊ฐ€์ •) k-๋ฒˆ์งธ ์›์†Œ๋ฅผ ์ฐพ๋Š” ์—ฐ์‚ฐ๋“ค์„ ์ˆ˜ํ–‰ํ•˜๋Š”๋ฐ ์‚ฌ์šฉํ•œ๋‹ค.
  • ๊ท ํ˜• ์žกํžŒ ์ด์ง„ ๊ฒ€์ƒ‰ ํŠธ๋ฆฌ(balanced BST) : ํŠธ๋ฆฌ์˜ ๋†’์ด๊ฐ€ ํ•ญ์ƒ **O(lgN)**์ด ๋˜๋„๋ก ํ•˜๋Š” ํŠธ๋ฆฌ. (ex. ๋ ˆ๋“œ-๋ธ”๋ž™ ํŠธ๋ฆฌ_Red-Black Tree)

๐Ÿ“์˜ˆ์ œ::๋„ˆ๋“œ์ธ๊ฐ€, ๋„ˆ๋“œ๊ฐ€ ์•„๋‹Œ๊ฐ€? 2 (ID: NERD2)

๋ฌธ์ œ : ๋„ˆ๋“œ์ง€์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ๊ธฐ์ค€์€ 1. ํ‘ผ ๋ฌธ์ œ์˜ ์ˆ˜/ 2. ์ƒˆ๋ฒฝ์— ๋จน์€ ๋ผ๋ฉด๊ทธ๋ฆ‡์ˆ˜ ์ด๋‹ค. ๋งŒ์•ฝ ํƒ€ ์ฐธ๊ฐ€์ž๋ณด๋‹ค ํ‘ผ ๋ฌธ์ œ์˜ ์ˆ˜๊ฐ€ ์ ๊ณ , ์ƒˆ๋ฒฝ์— ๋จน์€ ๋ผ๋ฉด ๊ทธ๋ฆ‡ ์ˆ˜๊ฐ€ ์ ๋‹ค๋ฉด ์ด ์‚ฌ๋žŒ์€ ๋Œ€ํšŒ์ž๊ฒฉ์ด ์—†๋‹ค๊ณ  ํŒ๋‹จํ•œ๋‹ค. ์ด ๋•Œ, ๊ฐ ์‚ฌ๋žŒ์ด ์ฐธ๊ฐ€์‹ ์ฒญ์„ ํ•  ๋•Œ๋งˆ๋‹ค ๋Œ€ํšŒ์— ์ฐธ๊ฐ€ํ•  ์ˆ˜ ์žˆ๋Š” ์‚ฌ๋žŒ๋“ค์˜ ์ˆ˜๊ฐ€ ์–ด๋–ป๊ฒŒ ๋ณ€ํ•˜๋Š”์ง€ ๊ณ„์‚ฐํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ ์ž‘์„ฑ.

โšก๏ธkeypointโšก๏ธ

  1. map<int, int>๋ฅผ ์ด์šฉํ•ด ๊ท ํ˜•์žกํžŒ BST๋ฅผ ๊ตฌํ˜„ํ•œ๋‹ค.
  2. lower_bound(x) ๋Š” x์ด์ƒ์˜ ๊ฐ’ ์ค‘ ๊ฐ€์žฅ ์ž‘์€ ๊ฐ’์„ ๋ฐ˜ํ™˜ํ•˜๋Š” STL์ด๋‹ค.
  3. ๋งŒ์•ฝ ์ƒˆ ์ฐธ๊ฐ€์ž์˜ 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)