- DP
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- ์๊ณ ๋ฆฌ์ฆ
- ๋ค์ต์คํธ๋ผ
- ์นด์นด์ค ์ฝํ
- ๋ฐฑ์ค
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- ํ๋ก๊ทธ๋๋จธ์ค
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- ํธ๋ฆฌ
- Python
- golang
- js
- ์ด๋ถํ์
- Union-Find
- ๋นํธ๋ง์คํน
- DFS
- nestjs
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- go
- ์น๋ฆฐ์ด
- LCs
- C++
- ๋นํธ๋งต
- ํ๋ฆฌ์จ๋ณด๋ฉ
- ์ฌ๊ท
- ์์ฝ๋
- BFS
- ์นด์นด์ค2021
- ์ํฐ๋
- Today
- Total
Hello Ocean! ๐ผ
[๋ฐฑ์ค/C++] 1013. Contact ๋ณธ๋ฌธ
๋ฌธ์
https://www.acmicpc.net/problem/1013
๋ฌธ์ ๊ฐ ๊ต์ฅํ ๊ธธ๊ณ ๋ณต์กํ๋ค.. ๊ผผ๊ผผํ ์ฝ์ด๋ณด๋ฉด์ ์ดํดํ๋ ์๊ฐ์ด ํ์ํ๋ค.
์์ฝํ์๋ฉด, ๊ฒฐ๊ณผ์ ์ผ๋ก ์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด์ด (100+1+|01)+ ํจํด์ ํด๋นํ๋์ง ์๋์ง๋ฅผ ํ๋จํ๋ฉด ๋๋ ๋ฌธ์ ์ด๋ค.
ํ์ด
(100+1+|01)+๋ฅผ ์ชผ๊ฐ์ ๋ณด์.
100+1+ = A, 01 = B๋ผ๊ณ ํ๋ฉด,
(A|B)+ ์ด๋ฏ๋ก, A๋ B๊ฐ ๊ณ์ ๋ฐ๋ณต์ ์ผ๋ก ๋ํ๋๋ฉด ๋๋ค.
B๋ 01 ์์ฒด์ด๊ณ ,
A ๋ 100+1+์ด๋ค. A๋ฅผ ๋ ๋ฏ์ด๋ณด๋ฉด,
10 0(0...) 1(1...) ์ด๋ฐ์์ด๊ธฐ ๋๋ฌธ์ 1001๋ถํฐ ...์๋ฆฌ์ 0์ด๋ 1์ด ๋ช๊ฐ๋ ๋ ๋ค์ด๊ฐ๋ ๋๋ ๊ตฌ์กฐ์ด๋ค.
๋ณต์กํ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ์ด ์๋์, ๊ทธ๋ฅ ๋ฌธ์์ด ๋งจ ์์์๋ถํฐ ํจํด์ผ๋ก if/else๋ก ๋๋ ์ ์ฌ๊ท๋ฅผ ๋๋ฆฌ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ค.
๋จผ์ ๋งจ ์์ด 1์ด๋ผ๋ฉด
100+1+์ธ์ง ํ์ธํด์ผ ํ๋ค. ์ฆ 1๋์ค๊ณ ์ ์ด๋ 0์ด 2๊ฐ, ์ ์ด๋ 1์ด 1๊ฐ ๋์ค๋์ง ํ์ธํด๋ณธ๋ค.
๊ทธ๋ฆฌ๊ณ , 1์ด 1๊ฐ ์ด์์ผ ๊ฒฝ์ฐ ๋ง์ง๋ง 1๋ค์ ๋์ค๋ 0์ ๊ฐ์๋ฅผ ์ถ๊ฐ๋ก ํ์ธํด์
0์ด 1๊ฐ๋ฉด : ๋ง์ง๋ง1๊น์ง ๋ฒ๋ฆฌ๊ณ ๋จ์ ๋ฌธ์์ด๋ก ๋ฐ๋ณตํ๋ค. (๋ค์ ํจํด์ด 01์ด๊ธฐ ๋๋ฌธ์)
ex) 100101... -> 01... , 1000111101... -> 01...
0์ด 2๊ฐ ์ด์์ด๋ฉด : ๋ง์ง๋ง 1์ ๋จ๊ธด ๋ฌธ์์ด๋ก ๋ฐ๋ณตํ๋ค (๋ค์ ํจํด๋ 100+1+์ด๊ธฐ ๋๋ฌธ์)
ex ) 10011000... -> 1000... , 1001111110001... -> 10001...
๋งจ ์์ด 0์ด๋ผ๋ฉด,
01์ ์๋ฅด๊ณ ๋จ์ ๋ฌธ์์ด๋ก ๋ฐ๋ณตํ๋ค.
์ด๋ ๊ฒ ์ฌ๊ท๋ฅผ ๋๋ค๊ฐ, ์กฐ๊ฑด์ ๋ง์ง ์๋ ๊ฒฝ์ฐ๊ฐ ๋์ค๋ฉด ํจํด์ ๋ง์กฑํ์ง ์๋๊ฒ์ผ๋ก ํ๋จํ๋ฉด๋๋ค.
์ฝ๋๋ฅผ ๋ณด๋๊ฒ ๋ ์ดํด๊ฐ ์ฌ์ธ ๊ฒ ๊ฐ๋ค..!
์ฝ๋
#include <iostream>
#include <string>
#define endl '\n'
using namespace std;
bool recursive(string s) {
bool flag = false;
int size = s.size();
if (size == 0) return true;
if (s[0] == '0')
if (s[1] == '1') flag |= recursive(s.substr(2)); // 01์๋ฅด๊ณ ๋ฐ๋ณต
else { // s[0] == '1'
// 0 ๊ตฌ๊ฐ
int i = 1;
while (i < size && s[i] == '0') {
i++;
}
if (i <= 2) {
return flag;
}
// 1 ๊ตฌ๊ฐ
int j = i;
while (j < size && s[j] == '1') {
j++;
}
// 1์ด 1๊ฐ
if (j == i + 1)
flag |= recursive(s.substr(j));
// 1์ด 2๊ฐ ์ด์์ผ ๋ ๋ง์ง๋ง 1 ๋ค์ 0 ๊ฐ์ ํ์ธ
if (j >= i + 2) {
if (j == size - 1) return flag;
if (j + 1 < size && s[j + 1] == '0')
flag |= recursive(s.substr(j-1));
else
flag |= recursive(s.substr(j));
}
}
return flag;
}
int main() {
int N; cin >> N;
for (int n = 0;n < N;n++) {
string input; cin >> input;
string answer = (recursive(input)) ? "YES" : "NO";
cout << answer << endl;
}
return 0;
}
๊ฒฐ๊ณผ
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++/ํ๋ก๊ทธ๋๋จธ์ค] ์ถ์ ํธ๋ํฝ (0) | 2021.11.17 |
---|---|
[๋ฐฑ์ค/C++] 14906. ์ค๋ฌํผ (0) | 2021.11.03 |
[๋ฐฑ์ค/Python] 7579. ์ฑ (0) | 2021.10.12 |
[๋ฐฑ์ค/Python] 20040. ์ฌ์ดํด ๊ฒ์ (0) | 2021.10.12 |
[CS/์๊ณ ๋ฆฌ์ฆ] ๊ฑฐ์ ์ ๋ ฌ๋ List์์ ์ด๋ค ์ ๋ ฌ์ด ๊ฐ์ฅ ํจ์จ์ ์ผ๊น? (0) | 2021.10.09 |