https://www.acmicpc.net/problem/9997
๋ฌธ์
์๊ทผ์ด๋ ์์ ์ด ๋ง๋ ํฐํธ๋ฅผ ํ ์คํธํ๊ธฐ ์ํ ๋ฌธ์ฅ์ ๋ง๋ค๋ ค๊ณ ํ๋ค. ํฐํธ์๋ ์ํ๋ฒณ ์๋ฌธ์๋ง ํฌํจ๋์ด ์๊ธฐ ๋๋ฌธ์, ๋ฌธ์ฅ์ ์ํ๋ฒณ ์๋ฌธ์๋ก ์์ฑํด์ผ ํ๋ค.
ํ ์คํธ ๋ฌธ์ฅ์๋ ์ํ๋ฒณ ์๋ฌธ์ 26๊ฐ๊ฐ ๋ชจ๋ ํฌํจ๋์ด ์์ด์ผ ํ๋ค.
์ฌ์ค ๋ฌธ์ ๋ฅผ ๋ง์ด ํ์ด๋ณธ ์ฌ๋์ด๋ผ๋ฉด, ๋ฌธ์ ๋ฅผ ์ฌ๊ธฐ๊น์ง ์ฝ์ด๋ ๋ฌด์จ ๋ฌธ์ ์ธ์ง ๊ฐ์ด ์กํ์ผ ํ๋ค.
์๊ทผ์ด๋ ๋จ์ด N๊ฐ๊ฐ ํฌํจ๋์ด ์๋ ์ฌ์ ์ ํ๋ ๊ฐ์ง๊ณ ์๋ค. ํ ์คํธ ๋ฌธ์ฅ์ ์ฌ์ ์ ํฌํจ๋ ๋จ์ด๋ง ์ด์ฉํด์ ๋ง๋ค ์ ์์ผ๋ฉฐ, ๊ฐ ๋จ์ด๋ ํ ๋ฒ์ฉ๋ง ์ฌ์ฉํด์ผ ํ๋ค. ๋, ๋จ์ด์ ์์๋ ์ค์ํ์ง ์๋ค. (“uvijek jedem sarmu” ์ “jedem sarmu uvijek”๋ ๊ฐ์ ๋ฌธ์ฅ์ด๋ค)
์๊ทผ์ด๊ฐ ๋ง๋ค ์ ์๋ ํ ์คํธ ๋ฌธ์ฅ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋จ์ด์ ๊ฐ์ N (1 ≤ N ≤ 25)๊ฐ ์ฃผ์ด์ง๋ค. ๋ค์ N๊ฐ ์ค์๋ ์ฌ์ ์ ํฌํจ๋์ด์๋ ๋จ์ด๊ฐ ์ฃผ์ด์ง๋ค. ๋จ์ด์ ๊ธธ์ด๋ 100์ ๋์ง ์์ผ๋ฉฐ, ์ค๋ณต๋๋ ๋จ์ด๋ ์ฃผ์ด์ง์ง ์๋๋ค.
์ถ๋ ฅ
์๊ทผ์ด๊ฐ ๋ง๋ค ์ ์๋ ํ ์คํธ ๋ฌธ์ฅ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
ํ์ด
์ฌ๊ท๋ก ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ค ๋ฐ์ ธ๋ณด๋ฉด ๋๋ค.
๊ทผ๋ฐ ๊ทธ ๊ณผ์ ์์ ๋นํธ๋ง์คํน์ ๊ณ๋ค์ฌ์...
(ํ์๋ ๋ณธ ๋ฌธ์ ๋ก ๋นํธ๋ฅผ ์ฒ์ ๋ค๋ค๋ดค๋ค.. ์์ธํ๊ฑด ์๋ ์ํ์ฐฉ์ค ์ฐธ๊ณ )
// ํ์ด : https://whkakrkr.tistory.com
#include <iostream>
#include <vector>
using namespace std;
int n, ans;
vector<int>words; // words[i] : i๋ฒ์งธ ๋จ์ด์ ๊ฐ ์ํ๋ฒณ ์ฌ์ฉ์ฌ๋ถ๋ฅผ ๋นํธ๋ก ์ ์ฅ
vector<bool>usedWord; // usedWord[i] : i๋ฒ์งธ ๋จ์ด๊ฐ ์ฌ์ฉ๋์๋๊ฐ?
void recur(int k, int usedAlphabet) {
if(k==n-1) {
if(usedAlphabet == (1<<26)-1) {
ans++;
}
return;
}
// ๋ค์ ๋จ์ด ํฌํจ ์ํจ
recur(k+1, usedAlphabet);
// ๋ค์ ๋จ์ด ํฌํจ
usedWord[k+1] = true;
recur(k+1, usedAlphabet|words[k+1]);
usedWord[k+1] = false;
}
int main() {
cin >> n;
words.assign(n, 0);
usedWord.assign(n, false);
for(int i=0; i<n; i++) {
string word;
cin >> word;
for(char ch : word) {
words[i] |= (1 << (ch-'a'));
}
}
recur(-1, 0);
cout << ans;
return 0;
}
์ํ์ฐฉ์ค
์ฒ์์๋ ๊ฐ ๋จ์ด๋ฅผ ๊ธธ์ด๊ฐ 26์ธ ๋ฐฐ์ด๋ก ์ ์ฅํ๋ค
words[i][j] : i๋ฒ์งธ ๋จ์ด๊ฐ j๋ฒ์งธ ์ํ๋ฒณ์ ๊ฐ์ง๊ณ ์๋๊ฐ ์ฌ๋ถ
์ญ์ ๊ฐ๋ ฅํ๊ฒ ์ค๋ ์๊ฐ์ด๊ณผ.
์ฌ๊ท๋ก ํ ์คํธ ๋ฌธ์ฅ์ ๋ง๋ค๋๋ง๋ค ๋ฐฐ์ด์ ๋๋ฉด์ ํฉํ๊ณ ,
์ฌ๊ท๊ฐ ๋๋ ๋ ๋ง๋ค ๋ฌธ์ฅ์ด ๋ง์กฑํ๋์ง (๋ชจ๋ ์ํ๋ฒณ์ด true์ธ์ง) ๋ฐฐ์ด์ ๋๊ณ ..
์ด์ฐจํผ 010011101101 ์ด๋ฐ์์ผ๋ก ์ ์ฅํ๊ฒ ๋ ํ ๋ฐ
์ด๊ฑธ ๋ฌธ์์ด? ๊ฐ์ด ํ๋๋ก ์ ์ฅํ๋ฉด ๋์ง ์์๊น ํ๋ ์๊ฐ์ด ๋ค์๊ณ
words[i]๋ฅผ ์ ์๋ก ์ ์ฅํ๋ค. ์ด์ฐจํผ ์ด ์ ์๋ฅผ ์ด์ง์๋ก ๋ฐ๊พธ๋ฉด 011011101 ์ด๋ฐํํ๊ฐ ๋๋๊น.
์ฌ๊ท๋ก ํ ์คํธ ๋ฌธ์ฅ์ ๋ง๋ค๋๋ง๋ค ๋นํธํฉ์ฐ์ฐ | ๋ฅผ ํ๋ฉด๋๊ณ
ํ ์คํธ ๋ฌธ์ฅ์ด ๋ง๋์ง ๊ฒ์ฆํ ๋๋ 2^26-1 (1์ด 26๊ฐ)์ ๊ฐ์์ง๋ง ํ์ธํ๋ฉด ๋๋ค
๋นํธ ์ฐ์ฐ ์์ฒญ ์ด๋ ค์ด๊ฑฐ๋ผ๊ณ ์๊ฐํ๋๋ฐ ์๊ฐ๋ณด๋ค ๋ณ๊ฑฐ ์์๋..!
์ ์ ์ฐ์ฐ์ด๋ ๋น์ท~ํ๋ค
๊ดํ ์ด์ง์, ๋นํธ, ์ด๋ฐ๊ฑฐ ๋ค๋ฃจ๋๊น ์ ๊ณต์ ๋ ๊ฒ ๊ฐ๊ณ .. ๋ฟ๋ฏํจ๋ ๋๋ฐฐ์์
// ํ์ด : https://whkakrkr.tistory.com
#include <iostream>
#include <vector>
using namespace std;
int n, ans;
vector<vector<bool>>words;
vector<bool>usedWord; // usedWord[i] : i๋ฒ์งธ ๋จ์ด๊ฐ ์ฌ์ฉ๋์๋๊ฐ?
bool canTest(vector<bool>&usedAlphabet) {
for(bool i : usedAlphabet) {
if(!i) {
return false;
}
}
return true;
}
void recur(int k, vector<bool>usedAlphabet) {
if(k==n-1) {
// ๋ก๊ทธ
// for(int i=0; i<n; i++) {
// if(usedWord[i]) {
// for(int j=0; j<26; j++) {
// if(words[i][j]) {
// cout << char(j+'a');
// }
// }
// cout << " ";
// }
// }
// for(int i=0; i<26; i++) {
// cout << usedAlphabet[i];
// }
// cout << "\n";
//
if(canTest(usedAlphabet)) {
ans++;
}
return;
}
// ๋ค์ ๋จ์ด ํฌํจ ์ํจ
recur(k+1, usedAlphabet);
// ๋ค์ ๋จ์ด ํฌํจ
usedWord[k+1] = true;
vector<bool>newUsedAlphabet = usedAlphabet;
for(int i=0; i<26; i++) {
if(words[k+1][i]) {
newUsedAlphabet[i] = true;
}
}
recur(k+1, newUsedAlphabet);
usedWord[k+1] = false;
}
int main() {
cin >> n;
words.assign(n, vector<bool>(26, false));
usedWord.assign(n, false);
for(int i=0; i<n; i++) {
string word;
cin >> word;
for(char ch : word) {
words[i][ch-'a'] = true;
}
}
recur(-1, vector<bool>(26,false));
cout << ans;
return 0;
}
'๐๏ธ ICPC Sinchon > Backtracking' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ][C++] ๋ฐฑ์ค 14501๋ฒ: ํด์ฌ (1) | 2024.11.15 |
---|---|
[BOJ][C++] ๋ฐฑ์ค 23057๋ฒ: ๋์ ์ซ์์ (4) | 2024.10.18 |
[BOJ][C++] ๋ฐฑ์ค 1497๋ฒ: ๊ธฐํ์ฝ์ํธ (0) | 2024.08.17 |
[BOJ][C++] ๋ฐฑ์ค 1759๋ฒ: ์ํธ ๋ง๋ค๊ธฐ (0) | 2023.11.22 |
[BOJ][C++] ๋ฐฑ์ค 14888๋ฒ: ์ฐ์ฐ์ ๋ผ์๋ฃ๊ธฐ (0) | 2023.07.06 |