๋ฌธ์ & ์ถ์ฒ |
์ฝ๋ฉํ ์คํธ ์ฐ์ต - ํ๋ณดํค | ํ๋ก๊ทธ๋๋จธ์ค
[["100","ryan","music","2"],["200","apeach","math","2"],["300","tube","computer","3"],["400","con","computer","4"],["500","muzi","music","3"],["600","apeach","music","2"]] 2
programmers.co.kr
'19 ์นด์นด์ค ์ฝ๋ฉ ํ ์คํธ (C++) - YouTube
www.youtube.com
ํ์ด๊ณผ์ |
(1) ๊ท์น
๊ด๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ๋ฆด๋ ์ด์ (Relation)์ ํํ(Tuple)์ ์ ์ผํ๊ฒ ์๋ณํ ์ ์๋ ์์ฑ(Attribute) ๋๋ ์์ฑ์ ์งํฉ ์ค, ๋ค์ ๋ ์ฑ์ง์ ๋ง์กฑํ๋ ๊ฒ์ ํ๋ณด ํค(Candidate Key)๋ผ๊ณ ํ๋ค.
- ์ ์ผ์ฑ(uniqueness) : ๋ฆด๋ ์ด์ ์ ์๋ ๋ชจ๋ ํํ์ ๋ํด ์ ์ผํ๊ฒ ์๋ณ๋์ด์ผ ํ๋ค.
- ์ต์์ฑ(minimality) : ์ ์ผ์ฑ์ ๊ฐ์ง ํค๋ฅผ ๊ตฌ์ฑํ๋ ์์ฑ(Attribute) ์ค ํ๋๋ผ๋ ์ ์ธํ๋ ๊ฒฝ์ฐ ์ ์ผ์ฑ์ด ๊นจ์ง๋ ๊ฒ์ ์๋ฏธํ๋ค. ์ฆ, ๋ฆด๋ ์ด์ ์ ๋ชจ๋ ํํ์ ์ ์ผํ๊ฒ ์๋ณํ๋ ๋ฐ ๊ผญ ํ์ํ ์์ฑ๋ค๋ก๋ง ๊ตฌ์ฑ๋์ด์ผ ํ๋ค.

์์ ์๋ฅผ ์ค๋ช ํ๋ฉด, ํ์์ ์ธ์ ์ฌํญ ๋ฆด๋ ์ด์ ์์ ๋ชจ๋ ํ์์ ๊ฐ์ ์ ์ผํ ํ๋ฒ์ ๊ฐ์ง๊ณ ์๋ค.
๋ฐ๋ผ์ ํ๋ฒ์ ๋ฆด๋ ์ด์ ์ ํ๋ณด ํค๊ฐ ๋ ์ ์๋ค.
๊ทธ๋ค์ ์ด๋ฆ์ ๋ํด์๋ ๊ฐ์ ์ด๋ฆ(apeach)์ ์ฌ์ฉํ๋ ํ์์ด ์๊ธฐ ๋๋ฌธ์, ์ด๋ฆ์ ํ๋ณด ํค๊ฐ ๋ ์ ์๋ค.
๊ทธ๋ฌ๋, ๋ง์ฝ [์ด๋ฆ, ์ ๊ณต]์ ํจ๊ป ์ฌ์ฉํ๋ค๋ฉด ๋ฆด๋ ์ด์ ์ ๋ชจ๋ ํํ์ ์ ์ผํ๊ฒ ์๋ณ ๊ฐ๋ฅํ๋ฏ๋ก ํ๋ณด ํค๊ฐ ๋ ์ ์๊ฒ ๋๋ค.
๋ฌผ๋ก [์ด๋ฆ, ์ ๊ณต, ํ๋ ]์ ํจ๊ป ์ฌ์ฉํด๋ ๋ฆด๋ ์ด์ ์ ๋ชจ๋ ํํ์ ์ ์ผํ๊ฒ ์๋ณํ ์ ์์ง๋ง, ์ต์์ฑ์ ๋ง์กฑํ์ง ๋ชปํ๊ธฐ ๋๋ฌธ์ ํ๋ณด ํค๊ฐ ๋ ์ ์๋ค.
๋ฐ๋ผ์, ์์ ํ์ ์ธ์ ์ฌํญ์ ํ๋ณดํค๋ ํ๋ฒ, [์ด๋ฆ, ์ ๊ณต] ๋ ๊ฐ๊ฐ ๋๋ค.
bit๋ฅผ ์ฌ์ฉ, ๊ฐ Attribute(column)๊ณผ ์๋์ 1์ ๋น๊ตํ์ฌ ํ๋ณดํค๋ฅผ ์ฐพ์ต๋๋ค.
0000 (0) |
X |
0001 (1) |
ํ๋ฒ |
0010 (2) |
์ด๋ฆ |
0011 (3) |
ํ๋ฒ,์ด๋ฆ |
0100 (4) |
์ ๊ณต |
0101 (5) |
ํ๋ฒ,์ ๊ณต |
0110 (6) |
์ด๋ฆ,์ ๊ณต |
0111 (7) |
ํ๋ฒ,์ด๋ฆ,์ ๊ณต |
1000 (8) |
ํ๋ |
1001 (9) |
ํ๋ฒ,ํ๋ |
1010 (10) |
์ด๋ฆ,ํ๋ |
1011 (11) |
ํ๋ฒ,์ด๋ฆ,ํ๋ |
1100 (12) |
์ ๊ณต,ํ๋ |
1101 (13) |
ํ๋ฒ,์ ๊ณต,ํ๋ |
1110 (14) |
์ด๋ฆ,์ ๊ณต,ํ๋ |
1111 (15) |
ํ๋ฒ,์ด๋ฆ,์ ๊ณต,ํ๋ |
(2) ์์
1๋ถํฐ(i) Attribute์ ๊ธธ์ด(1 << Attribute๊ธธ์ด) ๊น์ง, i ๊ฐ ํ๋ณดํค๋ฅผ ๋ง์กฑํ๋์ง ๊ฒ์ํฉ๋๋ค.
์๋ฅผ๋ค์ด i๊ฐ 5(0101)์ด๋ผ๋ฉด, ํ๋ฒ์ ์ค๋ณต์ด ์๋์ง ํ์ธ, ์ ๊ณต์ ์ค๋ณต์ด ์๋์ง ํ์ธํฉ๋๋ค.
ํ๋ณดํค ์กฐ๊ฑด์ ๋ง์กฑํ๋ค๋ฉด Attribute์ i ๊ฐ์ ์์๋ฒกํฐ์ push ํฉ๋๋ค.
(์ ์ผ์ฑ ์ฒดํฌ๋ฅผ ํ์ง ์์ผ๋ฏ๋ก 0001๊ณผ 0101 ๋๋ค ์์๋ฒกํฐ์ ๋ค์ด๊ฐ๊ฒ ๋ฉ๋๋ค)
1์ด ๋ง์ bit์์๋๋ก ๋ด๋ฆผ์ฐจ์ ํ ํ, ์์๋ฒกํฐ.front()(1์ด ์ ์ผ ๋ง์ bit) ์ ์์๋ฒกํฐ.back()(1์ด ์ ์ผ ์ ์ bit) ๋ฅผ ๋น๊ตํ์ฌ
์ ์ผ์ฑ์ ๋ง์กฑํ์ง ์๋ ํ๋ณดํค๋ ์ ๊ฑฐํฉ๋๋ค.(0001์ด ํ๋ณดํค๋ผ๋ฉด 0101์ ์ ๊ฑฐํฉ๋๋ค)
(3) ์ฝ๋
#include <string> | |
#include <vector> | |
#include <algorithm> | |
using namespace std; | |
int countBits(int n) | |
{ | |
int ret = 0; | |
while (n) | |
{ | |
if (n & 1) ret++; | |
n = n >> 1; | |
} | |
return ret; | |
} | |
bool cmp(int a, int b) | |
{ | |
//์ผ์ง ๋นํธ๋ฅผ ์นด์ดํธ | |
int x = countBits(a), y = countBits(b); | |
return x > y;//๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ | |
} | |
bool check(vector<vector<string>> relation, int low, int col, int subset) | |
{ | |
for (int i = 0; i < low - 1; i++) | |
{ | |
for (int j = i + 1; j < low; j++) | |
{ | |
bool isSame = true; | |
for (int k = 0; k < col; k++) | |
{ | |
if ((subset & 1 << k) == 0) continue;//ex) k๋ 1, (0010 & 0001)๋ก ์ด๋ผ๋ฉด, ๊ฒ์ํ๋ ค๋ Attrit์ด ์๋๋ค | |
if (relation[i][k] != relation[j][k])//col ํ์ค์ ์ค๋ณต๊ฐ์ด ์๋์ง ํ์ธ | |
{ | |
//์ ์ผ์ฑ ํฌํจ, ์ต์์ฑ์ ๋ง์กฑํ๋ฏ๋ก | |
isSame = false; | |
break; | |
} | |
} | |
if (isSame) | |
{ | |
return false; | |
} | |
} | |
} | |
return true; | |
} | |
int solution(vector<vector<string>> relation) | |
{ | |
int answer = 0; | |
vector<int> candidates;//ํ๋ณดํค | |
int low = relation.size(); | |
int col = relation.front().size(); | |
//์ปฌ๋ผ์ค, ํ๋ณดํค ์ฐพ๋๋ค | |
for (int i = 1; i <= (1 << col); i++)// | |
{ | |
if (check(relation, low, col, i)) | |
candidates.push_back(i); | |
} | |
sort(candidates.begin(), candidates.end(), cmp); | |
while (!candidates.empty()) | |
{ | |
int n = candidates.back();//1์ ๊ฐฏ์๊ฐ ์ ์ผ ์ ์๊ฐ๋ถํฐ | |
candidates.pop_back(); | |
answer++; | |
//์ ์ผ์ฑ ์ฒดํฌ | |
for (vector<int>::iterator it = candidates.begin(); it != candidates.end(); ) | |
{ | |
if ((n & *it) == n) | |
it = candidates.erase(it); | |
else it++; | |
} | |
} | |
return answer; | |
} |
+ ๋ ์งง๊ณ ๊น๋ํ ์ฝ๋๋ฅผ ๋ฐ๊ฒฌํ์ฌ ์ถ๊ฐํฉ๋๋ค.
[ํ๋ก๊ทธ๋๋จธ์ค์ w*db , ํ*์ฉ , ์*์ญ , ์ฌํ , min**** Jeong ์ธ 3 ๋ช ๋ถ์ ์ฝ๋]
#include <bits/stdc++.h> | |
using namespace std; | |
bool possi(vector<int> &vec,int now){ | |
for(int i=0;i<vec.size();i++) | |
if((vec[i]&now)==vec[i])return false; | |
return true; | |
} | |
int solution(vector<vector<string>> relation) { | |
int n=relation.size(); | |
int m=relation[0].size(); | |
vector<int> ans; | |
for(int i=1;i<(1<<m);i++){ | |
set<string> s; | |
for(int j=0;j<n;j++){ | |
string now=""; | |
for(int k=0;k<m;k++){ | |
if(i&(1<<k))now+=relation[j][k]; | |
} | |
s.insert(now); | |
} | |
if(s.size()==n&&possi(ans,i))ans.push_back(i); | |
} | |
return ans.size(); | |
} |