Jekyll2023-05-06T10:18:41+00:00https://biewoom.github.io/atom.xml비움수박 겉이 아닌 수박 속에 집중하자.유정민카카오 페스티벌: GPS2020-06-04T00:00:00+00:002020-06-04T00:00:00+00:00https://biewoom.github.io/coding%20test/kakao%202017/2020/06/04/GPS<blockquote>
<p>출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges<br /></p>
</blockquote>
<h1 id="핵심-개념">핵심 개념</h1>
<ol>
<li>DP(dynamic programming)</li>
<li>edgeMap 만들기</li>
</ol>
<h1 id="팁">팁</h1>
<p>여기서 주목하셔야할 문제 조건은 k값이 충분히 작고, Node 번호들이 연속적이라는 겁니다.<br />
따라서 아래처럼 DP를 작성하시고 문제를 푸시면 좋습니다.<br />
dp[i][j] = Node의 i번쨰 값이 j이고 i번째까지 경로가 valid할 때 수정의 최소 횟수<br /></p>
<p>다만 DP를 채울 때 다음 노드 값을 (1, N) 모두를 고려하는 건 비효율적입니다.<br />
※ i번 째일 때 EdgeMap을 활용해 i+1의 노드 값을 가지치기 할 수 있었습니다.<br /></p>
<p>이미 dp[i][j]가 INF이면 그 다음 값을 구하는 건 크게 의미가 없습니다.<br /></p>
<h1 id="그림-설명">그림 설명</h1>
<p><img src="/assets/images/PS/2017-kakao-festival/gps1.png" alt="image" height="50%" width="80%" /></p>
<p><img src="/assets/images/PS/2017-kakao-festival/gps2.png" alt="image" height="50%" width="80%" /></p>
<h3 id="시간-효율성">시간 효율성</h3>
<p>Initialize 과정: O( (m * 2) + (k * n) )<br />
dynamic programming 과정: O( k(n + m) )<br /></p>
<h1 id="code">Code:</h1>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">java.util.*</span><span class="o">;</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Main</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">Scanner</span> <span class="n">sc</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Scanner</span><span class="o">(</span><span class="nc">System</span><span class="o">.</span><span class="na">in</span><span class="o">);</span>
<span class="kt">int</span> <span class="n">n</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">());</span>
<span class="kt">int</span> <span class="n">m</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">());</span>
<span class="kt">int</span><span class="o">[][]</span> <span class="n">edge_list</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">int</span><span class="o">[</span><span class="n">m</span><span class="o">][</span><span class="mi">2</span><span class="o">];</span>
<span class="nc">String</span> <span class="n">tmpLine</span> <span class="o">=</span> <span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">();</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">tmp</span> <span class="o">=</span> <span class="n">tmpLine</span><span class="o">.</span><span class="na">substring</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="n">tmpLine</span><span class="o">.</span><span class="na">length</span><span class="o">()</span> <span class="o">-</span> <span class="mi">1</span><span class="o">).</span><span class="na">split</span><span class="o">(</span><span class="s">"\\],\\["</span><span class="o">);</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">tmp</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">tt</span> <span class="o">=</span> <span class="n">tmp</span><span class="o">[</span><span class="n">i</span><span class="o">].</span><span class="na">split</span><span class="o">(</span><span class="s">", "</span><span class="o">);</span>
<span class="n">edge_list</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="mi">0</span><span class="o">]</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">tt</span><span class="o">[</span><span class="mi">0</span><span class="o">]);</span>
<span class="n">edge_list</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="mi">1</span><span class="o">]</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">tt</span><span class="o">[</span><span class="mi">1</span><span class="o">]);</span>
<span class="o">}</span>
<span class="kt">int</span> <span class="n">k</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">());</span>
<span class="kt">int</span><span class="o">[]</span> <span class="n">gps_log</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">int</span><span class="o">[</span><span class="n">k</span><span class="o">];</span>
<span class="nc">String</span> <span class="n">tempLine</span> <span class="o">=</span> <span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">();</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">temp</span> <span class="o">=</span> <span class="n">tempLine</span><span class="o">.</span><span class="na">substring</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="n">tempLine</span><span class="o">.</span><span class="na">length</span><span class="o">()</span> <span class="o">-</span> <span class="mi">1</span><span class="o">).</span><span class="na">split</span><span class="o">(</span><span class="s">", "</span><span class="o">);</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">temp</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="n">gps_log</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">temp</span><span class="o">[</span><span class="n">i</span><span class="o">]);</span>
<span class="o">}</span>
<span class="kt">int</span> <span class="n">answer</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Solution</span><span class="o">().</span><span class="na">solution</span><span class="o">(</span><span class="n">n</span><span class="o">,</span> <span class="n">m</span><span class="o">,</span> <span class="n">edge_list</span><span class="o">,</span> <span class="n">k</span><span class="o">,</span> <span class="n">gps_log</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">answer</span><span class="o">);</span>
<span class="n">sc</span><span class="o">.</span><span class="na">close</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">class</span> <span class="nc">Solution</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">initializeDP</span><span class="o">(</span><span class="kt">int</span><span class="o">[][]</span> <span class="n">dp</span><span class="o">,</span> <span class="kt">int</span> <span class="n">inf</span><span class="o">)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">r</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">r</span> <span class="o"><</span> <span class="n">dp</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">r</span><span class="o">++)</span> <span class="o">{</span>
<span class="nc">Arrays</span><span class="o">.</span><span class="na">fill</span><span class="o">(</span><span class="n">dp</span><span class="o">[</span><span class="n">r</span><span class="o">],</span> <span class="n">inf</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">initializeEdgeMap</span><span class="o">(</span><span class="kt">int</span><span class="o">[][]</span> <span class="n">edge_list</span><span class="o">,</span>
<span class="nc">Map</span><span class="o"><</span><span class="nc">Integer</span><span class="o">,</span> <span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Integer</span><span class="o">>></span> <span class="n">edgeMap</span><span class="o">)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">edge_list</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="kt">int</span> <span class="n">v1</span> <span class="o">=</span> <span class="n">edge_list</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="mi">0</span><span class="o">];</span>
<span class="kt">int</span> <span class="n">v2</span> <span class="o">=</span> <span class="n">edge_list</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="mi">1</span><span class="o">];</span>
<span class="k">if</span> <span class="o">(</span><span class="n">edgeMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">v1</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span>
<span class="n">edgeMap</span><span class="o">.</span><span class="na">put</span><span class="o">(</span><span class="n">v1</span><span class="o">,</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Integer</span><span class="o">>());</span>
<span class="k">if</span> <span class="o">(</span><span class="n">edgeMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">v2</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span>
<span class="n">edgeMap</span><span class="o">.</span><span class="na">put</span><span class="o">(</span><span class="n">v2</span><span class="o">,</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Integer</span><span class="o">>());</span>
<span class="n">edgeMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">v1</span><span class="o">).</span><span class="na">add</span><span class="o">(</span><span class="n">v2</span><span class="o">);</span>
<span class="n">edgeMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">v2</span><span class="o">).</span><span class="na">add</span><span class="o">(</span><span class="n">v1</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="nf">solution</span><span class="o">(</span><span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span><span class="o">[][]</span> <span class="n">edge_list</span><span class="o">,</span> <span class="kt">int</span> <span class="n">k</span><span class="o">,</span> <span class="kt">int</span><span class="o">[]</span> <span class="n">gps_log</span><span class="o">)</span> <span class="o">{</span>
<span class="kd">final</span> <span class="kt">int</span> <span class="no">INF</span> <span class="o">=</span> <span class="mi">100000</span><span class="o">;</span>
<span class="kt">int</span> <span class="nc">Min</span> <span class="o">=</span> <span class="no">INF</span><span class="o">;</span>
<span class="nc">Map</span><span class="o"><</span><span class="nc">Integer</span><span class="o">,</span> <span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Integer</span><span class="o">>></span> <span class="n">edgeMap</span> <span class="o">=</span>
<span class="k">new</span> <span class="nc">Hashtable</span><span class="o"><</span><span class="nc">Integer</span><span class="o">,</span> <span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Integer</span><span class="o">>>();</span>
<span class="n">initializeEdgeMap</span><span class="o">(</span><span class="n">edge_list</span><span class="o">,</span> <span class="n">edgeMap</span><span class="o">);</span>
<span class="kt">int</span><span class="o">[][]</span> <span class="n">dp</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">int</span><span class="o">[</span><span class="n">k</span><span class="o">][</span><span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="o">];</span>
<span class="n">initializeDP</span><span class="o">(</span><span class="n">dp</span><span class="o">,</span> <span class="no">INF</span><span class="o">);</span>
<span class="kt">int</span> <span class="n">start</span> <span class="o">=</span> <span class="n">gps_log</span><span class="o">[</span><span class="mi">0</span><span class="o">];</span>
<span class="kt">int</span> <span class="n">end</span> <span class="o">=</span> <span class="n">gps_log</span><span class="o">[</span><span class="n">k</span> <span class="o">-</span> <span class="mi">1</span><span class="o">];</span>
<span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">start</span><span class="o">]</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">index</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">index</span> <span class="o"><</span> <span class="n">k</span> <span class="o">-</span> <span class="mi">1</span><span class="o">;</span> <span class="n">index</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">node</span> <span class="o">=</span> <span class="mi">1</span><span class="o">;</span> <span class="n">node</span> <span class="o"><</span> <span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="o">;</span> <span class="n">node</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">dp</span><span class="o">[</span><span class="n">index</span><span class="o">][</span><span class="n">node</span><span class="o">]</span> <span class="o">==</span> <span class="no">INF</span><span class="o">)</span>
<span class="k">continue</span><span class="o">;</span>
<span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Integer</span><span class="o">></span> <span class="n">nextCandidates</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o"><>(</span><span class="n">edgeMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">node</span><span class="o">));</span>
<span class="n">nextCandidates</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">node</span><span class="o">);</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">nextNode</span> <span class="o">:</span> <span class="n">nextCandidates</span><span class="o">)</span> <span class="o">{</span>
<span class="kt">int</span> <span class="n">value</span> <span class="o">=</span> <span class="n">dp</span><span class="o">[</span><span class="n">index</span><span class="o">][</span><span class="n">node</span><span class="o">];</span>
<span class="k">if</span> <span class="o">(</span><span class="n">nextNode</span> <span class="o">!=</span> <span class="n">gps_log</span><span class="o">[</span><span class="n">index</span> <span class="o">+</span> <span class="mi">1</span><span class="o">])</span>
<span class="n">value</span><span class="o">++;</span>
<span class="n">dp</span><span class="o">[</span><span class="n">index</span> <span class="o">+</span> <span class="mi">1</span><span class="o">][</span><span class="n">nextNode</span><span class="o">]</span> <span class="o">=</span> <span class="nc">Math</span><span class="o">.</span><span class="na">min</span><span class="o">(</span><span class="n">dp</span><span class="o">[</span><span class="n">index</span> <span class="o">+</span> <span class="mi">1</span><span class="o">][</span><span class="n">nextNode</span><span class="o">],</span> <span class="n">value</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="k">return</span> <span class="o">((</span><span class="n">dp</span><span class="o">[</span><span class="n">k</span> <span class="o">-</span> <span class="mi">1</span><span class="o">][</span><span class="n">end</span><span class="o">]</span> <span class="o">!=</span> <span class="no">INF</span><span class="o">)</span> <span class="o">?</span> <span class="n">dp</span><span class="o">[</span><span class="n">k</span> <span class="o">-</span> <span class="mi">1</span><span class="o">][</span><span class="n">end</span><span class="o">]</span> <span class="o">:</span> <span class="o">-</span><span class="mi">1</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>유정민2017-카카오 페스티벌-100% 풀이카카오 페스티벌: 사천성2020-06-04T00:00:00+00:002020-06-04T00:00:00+00:00https://biewoom.github.io/coding%20test/kakao%202017/2020/06/04/fourheaven<blockquote>
<p>출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges<br /></p>
</blockquote>
<h1 id="핵심개념">핵심개념</h1>
<p><1> Find 함수 구현<br />
<2> BackTracking<br />
<3> String -> char Array<br /></p>
<h1 id="팁">팁</h1>
<p>String은 Type은 replace가 있긴 하지만 본래가 immutable한 자료구조입니다.<br />
Logic 수행 과정에서 잦은 변화가 있기 때문에 미리 char Array로 바꾸는 게 좋습니다.<br />
HashSet으로 우리가 계산해야 할 전체 tile 수를 먼저 구해놓는 것도 좋은 거 같습니다.<br /></p>
<p>전체적으로 BackTracking을 이용해 문제를 풀 수 있습니다. 그 과정은 아래와 같습니다.</p>
<ol>
<li><strong>제거할 수 있는 타일이 있는 지 검사한다.</strong></li>
<li>제거할 수 있는 게 있다면 타일을 제거한다.</li>
<li>제거했다면, 변환 후의 board로 다시 BackTracking을 수행한다.</li>
<li>제거하지 못했다면, 수행을 멈춘다.</li>
</ol>
<p>우리는 매번 제거할 수 있는 Tile이 있는 지를 검사를 해야합니다.<br />
여기서 주목해야할 점은 모든 제거하는 경우는 두 가지로 압축을 할 수 있다는 것입니다.<br /></p>
<ol>
<li>자신이 Tile 중 하나이고 나랑 같은 Tile을 수직 또는 수평에서 찾는다.</li>
<li>자신은 두 가지 Tile들을 이어주는 Bridge이고 수평에서 하나, 수직에서 하나 찾는다.<br /></li>
</ol>
<blockquote>
<p>제거하는 Logic의 자세한 내용은 밑에서 설명하겠습니다.</p>
</blockquote>
<h1 id="그림-설명">그림 설명</h1>
<p>Matrix의 모든 원소를 돌아가며 제거하는 타일이 있는 지를 체크해야합니다.<br />
이 때 Matrix의 원소는 3가지 경우가 있습니다.<br /></p>
<ol>
<li>자신이 타일인 경우(Capital alphabet)</li>
<li>자신이 빈 공간인 경우</li>
<li>자신이 Wall 인 경우</li>
</ol>
<h3 id="1번-경우">1번 경우</h3>
<p><img src="/assets/images/PS/2017-kakao-festival/find1.png" alt="image" height="50%" width="80%" /></p>
<p>자신은 Bridge 역할은 할 수 없고 직접 같은 타일이 있는지 검사해야합니다.<br /></p>
<h3 id="2번-경우">2번 경우</h3>
<p><img src="/assets/images/PS/2017-kakao-festival/find2.png" alt="image" height="50%" width="80%" /></p>
<p><img src="/assets/images/PS/2017-kakao-festival/find3.png" alt="image" height="50%" width="80%" /></p>
<p>자신은 타일의 역할을 할 수 없고 Bridge의 역할만 가능합니다.<br /></p>
<h3 id="3번-경우">3번 경우</h3>
<p>그냥 continue로 넘어가면 됩니다.<br /></p>
<h3 id="시간효율성">시간효율성</h3>
<p>Initialize 과정: O(m * n)<br />
BackTracking 과정: O(m * n * k) 단, k = 전체 타일의 종류 수<br />
Total: O(m * n * k)<br /></p>
<h1 id="code">Code:</h1>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">java.util.*</span><span class="o">;</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Main</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">Scanner</span> <span class="n">sc</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Scanner</span><span class="o">(</span><span class="nc">System</span><span class="o">.</span><span class="na">in</span><span class="o">);</span>
<span class="kt">int</span> <span class="n">m</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">());</span>
<span class="kt">int</span> <span class="n">n</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">());</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">board</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">String</span><span class="o">[</span><span class="n">m</span><span class="o">];</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">lines</span> <span class="o">=</span> <span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">().</span><span class="na">split</span><span class="o">(</span><span class="s">", "</span><span class="o">);</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="nc">String</span> <span class="n">input</span> <span class="o">=</span> <span class="n">lines</span><span class="o">[</span><span class="n">i</span><span class="o">].</span><span class="na">substring</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="o">);</span>
<span class="n">board</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">=</span> <span class="n">input</span><span class="o">;</span>
<span class="o">}</span>
<span class="nc">String</span> <span class="n">result</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Solution</span><span class="o">().</span><span class="na">solution</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">board</span><span class="o">);</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">result</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">class</span> <span class="nc">Solution</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kt">int</span> <span class="nf">checkRemovability</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">)</span> <span class="o">{</span>
<span class="kt">char</span> <span class="n">finalRemover</span> <span class="o">=</span> <span class="sc">'a'</span><span class="o">;</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">n</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span> <span class="o">{</span>
<span class="c1">// <First> I'm a wall, Skip myself!</span>
<span class="k">if</span> <span class="o">(</span><span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">==</span> <span class="sc">'*'</span><span class="o">)</span>
<span class="k">continue</span><span class="o">;</span>
<span class="c1">// <Second> I'm a point which help some tile to find his partener!</span>
<span class="k">else</span> <span class="nf">if</span> <span class="o">(</span><span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">==</span> <span class="sc">'.'</span><span class="o">)</span> <span class="o">{</span>
<span class="c1">// there are four cases:</span>
<span class="kt">char</span> <span class="n">upperCh</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findUpper</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">i</span> <span class="o">-</span> <span class="mi">1</span><span class="o">,</span> <span class="n">j</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">);</span>
<span class="kt">char</span> <span class="n">lowerCh</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findLower</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="o">,</span> <span class="n">j</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">);</span>
<span class="kt">char</span> <span class="n">leftCh</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findLeft</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">i</span><span class="o">,</span> <span class="n">j</span> <span class="o">-</span> <span class="mi">1</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">);</span>
<span class="kt">char</span> <span class="n">rightCh</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findRight</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">i</span><span class="o">,</span> <span class="n">j</span> <span class="o">+</span> <span class="mi">1</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">);</span>
<span class="c1">// 1: upper meet left</span>
<span class="k">if</span> <span class="o">(</span><span class="n">upperCh</span> <span class="o">!=</span> <span class="sc">'*'</span> <span class="o">&&</span> <span class="n">upperCh</span> <span class="o">!=</span> <span class="sc">'.'</span> <span class="o">&&</span> <span class="n">upperCh</span> <span class="o">==</span> <span class="n">leftCh</span><span class="o">)</span>
<span class="n">finalRemover</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findMin</span><span class="o">(</span><span class="n">finalRemover</span><span class="o">,</span> <span class="n">upperCh</span><span class="o">);</span>
<span class="c1">// 2: upper meet right</span>
<span class="k">if</span> <span class="o">(</span><span class="n">upperCh</span> <span class="o">!=</span> <span class="sc">'*'</span> <span class="o">&&</span> <span class="n">upperCh</span> <span class="o">!=</span> <span class="sc">'.'</span> <span class="o">&&</span> <span class="n">upperCh</span> <span class="o">==</span> <span class="n">rightCh</span><span class="o">)</span>
<span class="n">finalRemover</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findMin</span><span class="o">(</span><span class="n">finalRemover</span><span class="o">,</span> <span class="n">upperCh</span><span class="o">);</span>
<span class="c1">// 3: lower meet left</span>
<span class="k">if</span> <span class="o">(</span><span class="n">lowerCh</span> <span class="o">!=</span> <span class="sc">'*'</span> <span class="o">&&</span> <span class="n">lowerCh</span> <span class="o">!=</span> <span class="sc">'.'</span> <span class="o">&&</span> <span class="n">lowerCh</span> <span class="o">==</span> <span class="n">leftCh</span><span class="o">)</span>
<span class="n">finalRemover</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findMin</span><span class="o">(</span><span class="n">finalRemover</span><span class="o">,</span> <span class="n">lowerCh</span><span class="o">);</span>
<span class="c1">// 4: lower meet right</span>
<span class="k">if</span> <span class="o">(</span><span class="n">lowerCh</span> <span class="o">!=</span> <span class="sc">'*'</span> <span class="o">&&</span> <span class="n">lowerCh</span> <span class="o">!=</span> <span class="sc">'.'</span> <span class="o">&&</span> <span class="n">lowerCh</span> <span class="o">==</span> <span class="n">rightCh</span><span class="o">)</span>
<span class="n">finalRemover</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findMin</span><span class="o">(</span><span class="n">finalRemover</span><span class="o">,</span> <span class="n">lowerCh</span><span class="o">);</span>
<span class="o">}</span>
<span class="c1">// <Third> I'm a tile and find my partener!</span>
<span class="k">else</span> <span class="o">{</span>
<span class="kt">char</span> <span class="n">curCh</span> <span class="o">=</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">];</span>
<span class="k">if</span> <span class="o">(</span><span class="n">curCh</span> <span class="o">==</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findRight</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">i</span><span class="o">,</span> <span class="n">j</span> <span class="o">+</span> <span class="mi">1</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">))</span>
<span class="n">finalRemover</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findMin</span><span class="o">(</span><span class="n">finalRemover</span><span class="o">,</span> <span class="n">curCh</span><span class="o">);</span>
<span class="k">if</span> <span class="o">(</span><span class="n">curCh</span> <span class="o">==</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findLower</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="o">,</span> <span class="n">j</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">))</span>
<span class="n">finalRemover</span> <span class="o">=</span> <span class="n">userFind</span><span class="o">.</span><span class="na">findMin</span><span class="o">(</span><span class="n">finalRemover</span><span class="o">,</span> <span class="n">curCh</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="k">return</span> <span class="o">((</span><span class="n">finalRemover</span> <span class="o">==</span> <span class="sc">'a'</span><span class="o">)</span> <span class="o">?</span> <span class="o">-</span><span class="mi">1</span> <span class="o">:</span> <span class="o">(</span><span class="kt">int</span><span class="o">)</span><span class="n">finalRemover</span><span class="o">);</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">Remove</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">,</span> <span class="kt">char</span> <span class="n">ch</span><span class="o">)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">n</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">==</span> <span class="n">ch</span><span class="o">)</span>
<span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">=</span> <span class="sc">'.'</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="nf">backTracking</span><span class="o">(</span><span class="kt">int</span> <span class="n">leftTiles</span><span class="o">,</span> <span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">,</span>
<span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Character</span><span class="o">></span> <span class="n">answerList</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">leftTiles</span> <span class="o"><=</span> <span class="mi">0</span><span class="o">)</span>
<span class="k">return</span><span class="o">;</span>
<span class="kt">int</span> <span class="n">toBeRemovedTile</span> <span class="o">=</span> <span class="n">checkRemovability</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">);</span>
<span class="k">if</span> <span class="o">(</span><span class="n">toBeRemovedTile</span> <span class="o">></span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">Remove</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">,</span> <span class="o">(</span><span class="kt">char</span><span class="o">)</span><span class="n">toBeRemovedTile</span><span class="o">);</span>
<span class="n">answerList</span><span class="o">.</span><span class="na">add</span><span class="o">((</span><span class="kt">char</span><span class="o">)</span><span class="n">toBeRemovedTile</span><span class="o">);</span>
<span class="n">backTracking</span><span class="o">(</span><span class="n">leftTiles</span> <span class="o">-</span> <span class="mi">1</span><span class="o">,</span> <span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">,</span> <span class="n">answerList</span><span class="o">);</span>
<span class="o">}</span> <span class="k">else</span>
<span class="k">return</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="nc">String</span> <span class="nf">solution</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="nc">String</span><span class="o">[]</span> <span class="n">board</span><span class="o">)</span> <span class="o">{</span>
<span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">char</span><span class="o">[</span><span class="n">m</span><span class="o">][</span><span class="n">n</span><span class="o">];</span>
<span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Character</span><span class="o">></span> <span class="n">answerList</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Character</span><span class="o">>();</span>
<span class="n">userUtil</span><span class="o">.</span><span class="na">initializeCharBoard</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">,</span> <span class="n">board</span><span class="o">);</span>
<span class="kt">int</span> <span class="n">tilesNumber</span> <span class="o">=</span> <span class="n">userUtil</span><span class="o">.</span><span class="na">checkTiles</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">);</span>
<span class="n">backTracking</span><span class="o">(</span><span class="n">tilesNumber</span><span class="o">,</span> <span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">charBoard</span><span class="o">,</span> <span class="n">answerList</span><span class="o">);</span>
<span class="k">return</span> <span class="o">((</span><span class="n">answerList</span><span class="o">.</span><span class="na">size</span><span class="o">()</span> <span class="o">==</span> <span class="n">tilesNumber</span><span class="o">)</span> <span class="o">?</span> <span class="n">userUtil</span><span class="o">.</span><span class="na">getString</span><span class="o">(</span><span class="n">answerList</span><span class="o">)</span>
<span class="o">:</span> <span class="s">"IMPOSSIBLE"</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">class</span> <span class="nc">userFind</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">char</span> <span class="nf">findRight</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">int</span> <span class="n">x</span><span class="o">,</span> <span class="kt">int</span> <span class="n">y</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">)</span> <span class="o">{</span>
<span class="k">while</span> <span class="o">(</span><span class="n">y</span> <span class="o"><</span> <span class="n">n</span> <span class="o">&&</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">x</span><span class="o">][</span><span class="n">y</span><span class="o">]</span> <span class="o">==</span> <span class="sc">'.'</span><span class="o">)</span> <span class="o">{</span>
<span class="n">y</span><span class="o">++;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="o">((</span><span class="n">y</span> <span class="o">>=</span> <span class="n">n</span><span class="o">)</span> <span class="o">?</span> <span class="sc">'*'</span> <span class="o">:</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">x</span><span class="o">][</span><span class="n">y</span><span class="o">]);</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">char</span> <span class="nf">findLeft</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">int</span> <span class="n">x</span><span class="o">,</span> <span class="kt">int</span> <span class="n">y</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">)</span> <span class="o">{</span>
<span class="k">while</span> <span class="o">(</span><span class="n">y</span> <span class="o">></span> <span class="mi">0</span> <span class="o">&&</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">x</span><span class="o">][</span><span class="n">y</span><span class="o">]</span> <span class="o">==</span> <span class="sc">'.'</span><span class="o">)</span> <span class="o">{</span>
<span class="n">y</span><span class="o">--;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="o">((</span><span class="n">y</span> <span class="o"><</span> <span class="mi">0</span><span class="o">)</span> <span class="o">?</span> <span class="sc">'*'</span> <span class="o">:</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">x</span><span class="o">][</span><span class="n">y</span><span class="o">]);</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">char</span> <span class="nf">findUpper</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">int</span> <span class="n">x</span><span class="o">,</span> <span class="kt">int</span> <span class="n">y</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">)</span> <span class="o">{</span>
<span class="k">while</span> <span class="o">(</span><span class="n">x</span> <span class="o">></span> <span class="mi">0</span> <span class="o">&&</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">x</span><span class="o">][</span><span class="n">y</span><span class="o">]</span> <span class="o">==</span> <span class="sc">'.'</span><span class="o">)</span> <span class="o">{</span>
<span class="n">x</span><span class="o">--;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="o">((</span><span class="n">x</span> <span class="o"><</span> <span class="mi">0</span><span class="o">)</span> <span class="o">?</span> <span class="sc">'*'</span> <span class="o">:</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">x</span><span class="o">][</span><span class="n">y</span><span class="o">]);</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">char</span> <span class="nf">findLower</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">int</span> <span class="n">x</span><span class="o">,</span> <span class="kt">int</span> <span class="n">y</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">)</span> <span class="o">{</span>
<span class="k">while</span> <span class="o">(</span><span class="n">x</span> <span class="o"><</span> <span class="n">m</span> <span class="o">&&</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">x</span><span class="o">][</span><span class="n">y</span><span class="o">]</span> <span class="o">==</span> <span class="sc">'.'</span><span class="o">)</span> <span class="o">{</span>
<span class="n">x</span><span class="o">++;</span>
<span class="o">}</span>
<span class="k">return</span> <span class="o">((</span><span class="n">x</span> <span class="o">>=</span> <span class="n">m</span><span class="o">)</span> <span class="o">?</span> <span class="sc">'*'</span> <span class="o">:</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">x</span><span class="o">][</span><span class="n">y</span><span class="o">]);</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">char</span> <span class="nf">findMin</span><span class="o">(</span><span class="kt">char</span> <span class="n">a</span><span class="o">,</span> <span class="kt">char</span> <span class="n">b</span><span class="o">)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">a</span> <span class="o"><=</span> <span class="n">b</span><span class="o">)</span>
<span class="k">return</span> <span class="n">a</span><span class="o">;</span>
<span class="k">else</span>
<span class="k">return</span> <span class="n">b</span><span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">class</span> <span class="nc">userUtil</span> <span class="o">{</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="nc">String</span> <span class="nf">getString</span><span class="o">(</span><span class="nc">ArrayList</span><span class="o"><</span><span class="nc">Character</span><span class="o">></span> <span class="n">list</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">StringBuilder</span> <span class="n">builder</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">StringBuilder</span><span class="o">(</span><span class="n">list</span><span class="o">.</span><span class="na">size</span><span class="o">());</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">char</span> <span class="n">ch</span> <span class="o">:</span> <span class="n">list</span><span class="o">)</span> <span class="o">{</span>
<span class="n">builder</span><span class="o">.</span><span class="na">append</span><span class="o">(</span><span class="n">ch</span><span class="o">);</span>
<span class="o">}</span>
<span class="k">return</span> <span class="n">builder</span><span class="o">.</span><span class="na">toString</span><span class="o">();</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">initializeCharBoard</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">,</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">board</span><span class="o">)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">n</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span> <span class="o">{</span>
<span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">=</span> <span class="n">board</span><span class="o">[</span><span class="n">i</span><span class="o">].</span><span class="na">charAt</span><span class="o">(</span><span class="n">j</span><span class="o">);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">int</span> <span class="nf">checkTiles</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">char</span><span class="o">[][]</span> <span class="n">charBoard</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">HashSet</span><span class="o"><</span><span class="nc">Character</span><span class="o">></span> <span class="n">tempSet</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">HashSet</span><span class="o"><</span><span class="nc">Character</span><span class="o">>();</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">n</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">!=</span> <span class="sc">'.'</span> <span class="o">&&</span> <span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">!=</span> <span class="sc">'*'</span><span class="o">)</span>
<span class="n">tempSet</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">charBoard</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="k">return</span> <span class="n">tempSet</span><span class="o">.</span><span class="na">size</span><span class="o">();</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>유정민2017-카카오 페스티벌-100% 풀이카카오 블라인드: 무지의 먹방2020-06-04T00:00:00+00:002020-06-04T00:00:00+00:00https://biewoom.github.io/coding%20test/kakao%202019%20blind/2020/06/04/muzi<blockquote>
<p>출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges<br /></p>
</blockquote>
<h1 id="핵심-개념">핵심 개념</h1>
<p><1> Heap 힙 사용<br />
<2></p>
<h1 id="팁">팁</h1>
<h1 id="그림-설명">그림 설명</h1>
<h1 id="code">Code</h1>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">from</span> <span class="nn">heapq</span> <span class="kn">import</span> <span class="n">heappush</span><span class="p">,</span> <span class="n">heappop</span>
<span class="k">def</span> <span class="nf">solution</span><span class="p">(</span><span class="n">food_times</span><span class="p">,</span> <span class="n">k</span><span class="p">):</span>
<span class="n">hq</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">turn_stack</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">pre_k</span> <span class="o">=</span> <span class="n">last_omit</span> <span class="o">=</span> <span class="bp">None</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">food_times</span><span class="p">)):</span>
<span class="n">heappush</span><span class="p">(</span><span class="n">hq</span><span class="p">,</span> <span class="p">[</span><span class="n">food_times</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span> <span class="p">)</span>
<span class="k">while</span> <span class="n">hq</span> <span class="ow">and</span> <span class="n">k</span> <span class="o">>=</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">omit</span> <span class="o">=</span> <span class="n">heappop</span><span class="p">(</span><span class="n">hq</span><span class="p">)</span>
<span class="n">pre_k</span> <span class="o">=</span> <span class="n">k</span>
<span class="n">turns</span> <span class="o">=</span> <span class="n">omit</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">-</span> <span class="n">turn_stack</span>
<span class="n">k</span> <span class="o">-=</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">hq</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="o">*</span> <span class="n">turns</span>
<span class="n">turn_stack</span> <span class="o">+=</span> <span class="n">turns</span>
<span class="n">last_omit</span> <span class="o">=</span> <span class="n">omit</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="k">if</span> <span class="n">k</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">left_foods</span> <span class="o">=</span> <span class="nb">sorted</span><span class="p">(</span> <span class="p">[</span><span class="n">x</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">hq</span><span class="p">]</span> <span class="o">+</span> <span class="p">[</span><span class="n">last_omit</span><span class="p">]</span> <span class="p">)</span>
<span class="n">move</span> <span class="o">=</span> <span class="n">pre_k</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">left_foods</span><span class="p">)</span>
<span class="k">return</span> <span class="n">left_foods</span><span class="p">[</span><span class="n">move</span><span class="p">]</span>
<span class="k">else</span><span class="p">:</span> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
</code></pre></div></div>유정민2019-카카오 블라인드-100% 풀이Array structure: RAM과 연속성의 마법!2020-06-03T00:00:00+00:002020-06-03T00:00:00+00:00https://biewoom.github.io/fundamental%20ds/2020/06/03/array-structure<p>’ <strong>제목 그대로’ RAM의 마법이자, 많은 자료 구조들의 어머니인 Array 구조</strong> 입니다.<br />
이 글에서는 RAM과 Array 그리고 Dynamic-array에 대해서 설명 하겠습니다.<br /></p>
<h1 id="ram이란">RAM이란?</h1>
<p><img src="/assets/images/ds/basic/ram.png" alt="image" /></p>
<p>여기서 계속 말하는 RAM은 우리가 평소에 말하는 하드웨어 “RAM” 그거 맞습니다.<br />
<strong>이 RAM에 대해서 알아야, Array의 가치를 제대로 이해 할 수 있습니다.</strong><br /></p>
<p><img src="/assets/images/ds/basic/cpu-ram.png" alt="image" /></p>
<p>※CacheMemory(SRAM), MainMemory(DRAM) 등 더 깊은 것은 여기서 다루지 않겠습니다.</p>
<p>RAM은 위 그림 처럼 CPU 옆에 붙어서 우리의 명령코드를 수행합니다.<br />
CPU가 일련의 명령들을 수행하는 동안 값과 자료들을 읽고 기억하는 공간입니다.<br />
ROM과는 다르게, 전원이 꺼지거나 하면 값이 사라지는 volatile 메모리입니다.<br />
이까지의 내용은 많은 분들이 이미 아시는 내용 일 것이라고 생각합니다.<br /></p>
<p>하지만 우리가 이 글에서 주목 해야할 것은 바로 아래의 내용입니다.<br /></p>
<p>RAM은 <strong>Random Access 방식</strong>으로 데이터를 읽거나 기억하는 메모리입니다.<br />
그럼 Random Access 방식은 멀까요?<br />
결론부터 이야기하면, <strong>램에 저장된 어느 데이터든 접근 시간이 거의 동일하다.</strong><br />
더 이야기하자면, <strong>데이터의 주소만 알면 RAM은 그 주소로 순간 이동 할 수 있다.</strong> 입니다.<br /></p>
<p>랩 안에는 공간이 허용하는 한 집을 짓고, 집을 지을 때마다 주소 값이 생깁니다.<br />
<strong>우리가 어떤 주소를 알고 그것을 RAM에게 준다면 그 주소로 순간 이동을 합니다</strong>.<br />
그림으로 표현하면 램(RAM)은 아래와 같다고 생각하면 됩니다.</p>
<p><img src="/assets/images/ds/basic/Ram-address.png" alt="image" /></p>
<p>이 Array는 배열의 연속성을 통해 RAM을 이용한 기본 자료 구조입니다.<br /></p>
<blockquote>
<p>다른 방법으로는 Pointer를 통해 RAM을 이용한 <a href="/fundamental%20ds/2020/06/03/array-structure.html">Nodes 구조</a>가 있습니다.<br /></p>
</blockquote>
<h1 id="array와-연속성">Array와 연속성:</h1>
<p>Array란 <strong>데이터가 연속되어 저장된 배열</strong>입니다.<br />
메모리 기준에서 말하면, Array란 <strong>데이터들이 연속되는 메모리 주소를 가지는 배열</strong>입니다.<br /></p>
<p>여기서 계속 강조되는 것은 <strong>배열의 연속성</strong>이라는 것입니다.<br />
이것이 왜 중요한지는 아파트의 그림과 예를 들어 설명을 드리겠습니다.<br /></p>
<p><img src="/assets/images/ds/basic/array.png" alt="image" /></p>
<p>일단 <strong>Array란 눕힌 아파트와 같다고 생각할 수 있습니다.</strong><br />
Array 안에는 아파트의 호실처럼 공간들이 순차적으로 줄지어 있습니다.<br /></p>
<p>각 호실은 사실 제각각 고유의 주소(address)를 가지고 있습니다.<br />
<strong>각 호실은 연속되어 있기에 주소도 서로 연속되는 값을 가지게 됩니다.</strong><br />
<strong>아파트이기 때문에 아파트의 주소도 있고 주소는 맨 앞의 호실의 주소와 같습니다.</strong><br /></p>
<p><img src="/assets/images/ds/basic/array-ram1.png" alt="image" /></p>
<p>자, 여기서 우리는 <strong>RAM을 광속의 쿠팡맨이다</strong>라고 상상해 보겠습니다.<br />
쿠팡맨은 <strong>마을아파트가 굉장히 많기 때문에 방 하나 하나 주소를 다 기억하지는 못합니다.</strong><br />
대신 <strong>마을에 있는 아파트의 주소는 본사에 전화를 하게 되면 다 알 수가 있죠.</strong><br /></p>
<p><img src="/assets/images/ds/basic/array-ram2.png" alt="image" /></p>
<p>여기서 우리 쿠팡맨은 <strong>FF101아파트의 4호실로 가라!</strong>라는 미션을 받게됩니다.<br />
쿠팡맨은 광속이기 때문에 <strong>방의 주소만 안다면</strong> 순식간에 갈 수 있습니다.<br />
하지만 안타깝게도 <strong>쿠팡맨은 방 하나 하나의 고유의 주소는 모른다는 것이죠.</strong><br />
<strong>쿠팡맨은 과연 어떻게 방 고유의 주소를 얻을 수 있을까요?</strong><br /></p>
<p><img src="/assets/images/ds/basic/array-ram3.png" alt="image" /></p>
<p>해결 방법은 바로 <strong>본사에 전화해서 아파트의 주소를 알아내고</strong><br />
<strong>아파트의 호실은 연속적이다</strong> 라는 것을 이용하여 주소 값을 얻는 것입니다.<br />
위 문제의 경우에는 <strong>4호실은 0 호실에서 4만큼 떨어져 있으니, 아파트 주소 + 4 = 4호 주소</strong><br />
라는 사실을 알 수 있고, 쿠팡맨은 성공적으로 4호실의 주소로 순간이동 할 수 있습니다.<br /></p>
<p>위 이야기가 배열의 연속성을 통해 RAM을 이용하는 Array의 핵심입니다.<br /></p>
<h1 id="array와-관련된-자료구조들">Array와 관련된 자료구조들</h1>
<p>Array와 관련된 자료구조들은 사실 너무도 많습니다.<br />
사실 모든 구조가 계속 내려가면 Nodes 또는 Array로 되어 있기 떄문입니다.<br />
그 중에서 대표적인 것을 뽑자면 <strong>Unordered Map, binaryHeap</strong>정도가 있습니다.<br /></p>
<p>중요한 것은 <strong>위 자료구조들은 연속성을 이용한 Index 접근이 필요한 구조들</strong>이라는 것입니다.<br />
즉, <strong>Array 약점인 비효율적인 Insert, delete 등 보다 Index 접근이 중요한 구조들</strong>입니다.<br /></p>
<p>위를 이해하면 어떤 구조를 구현 할 때 Linked list로 구현해야 하나? Array로 구현해야 하나?<br />
고민들은 이전에 구현했던 기억으로 구현하는 것이 아니라 자연스럽게 구현할 수 있게 됩니다.<br /></p>
<p>가령 Map은 <strong>Hashing을 통해 얻은 Index를 사용해 빠르게 data에 접근해야 한다</strong>라는<br />
특성 때문에 “slots을 DynamicArray로 구현하는 것이 좋다”. 라는 통찰을 얻을 수 있습니다.<br /></p>유정민자료구조들의 어머니뻘인 Array구조란 무엇일까?Nodes structure: RAM과 포인터의 마법!2020-06-03T00:00:00+00:002020-06-03T00:00:00+00:00https://biewoom.github.io/fundamental%20ds/2020/06/03/nodes-structure<p>’ <strong>제목 그대로’ RAM의 마법이자, 자료 구조들의 아버지인 Nodes 구조</strong> 입니다.<br />
이 글에서는 RAM과 Node structure 그리고 Linked-list에 대해서 설명 하겠습니다.<br /></p>
<h1 id="ram이란">RAM이란?</h1>
<p><img src="/assets/images/ds/basic/ram.png" alt="image" /></p>
<p>여기서 계속 말하는 RAM은 우리가 평소에 말하는 하드웨어 “RAM” 그거 맞습니다.<br />
<strong>이 RAM에 대해서 알아야, Nodes structure의 가치를 제대로 이해 할 수 있습니다.</strong><br /></p>
<p><img src="/assets/images/ds/basic/cpu-ram.png" alt="image" /></p>
<p>RAM은 위 그림 처럼 CPU 옆에 붙어서 우리의 명령코드를 수행합니다.<br />
CPU가 일련의 명령들을 수행하는 동안 값과 자료들을 읽고 기억하는 공간입니다.<br />
ROM과는 다르게, 전원이 꺼지거나 하면 값이 사라지는 volatile 메모리입니다.<br />
이 까지의 내용은 많은 분들이 이미 아시는 내용일 거 라고 생각합니다.<br /></p>
<p>하지만 우리가 이 글에서 주목 해야할 것은 바로 아래의 내용입니다.<br /></p>
<p>RAM은 <strong>Random Access 방식</strong>으로 데이터를 읽거나 기억하는 메모리입니다.<br />
그럼 Random Access 방식은 멀까요?<br />
결론부터 이야기하면, <strong>램에 저장된 어느 데이터든 접근 시간이 거의 동일하다.</strong><br />
비유을 들자면, <strong>주소만 알면 그 주소로 순간 이동 할 수 있다.</strong> 입니다.<br /></p>
<p>랩 안에는 공간이 허용하는 한 집을 짓고, 집을 지을 때마다 주소 값이 생깁니다.<br />
<strong>우리가 어떤 주소를 알고 그것을 RAM에게 준다면 그 주소로 순간이동 하는 거죠</strong>.<br />
그림으로 표현하면 램(RAM)은 아래와 같다고 생각하면 됩니다.</p>
<p><img src="/assets/images/ds/basic/Ram-address.png" alt="image" /></p>
<p>이 Nodes 구조는 Pointer 라는 것을 통해 RAM의 특징을 구현한 자료구조입니다.<br /></p>
<blockquote>
<p>다른 방법으로는 연속성을 통해 RAM의 특징을 구현한 <a href="/fundamental%20ds/2020/06/03/array-structure.html">Array 구조</a>가 있습니다.<br /></p>
</blockquote>
<h1 id="node-구조와-pointer포인터란">Node 구조와 Pointer(포인터)란?</h1>
<p>Node란 <strong>어떤 주소의 포인터와 고유의 값을 Attribute</strong>로 가진 객체입니다.<br />
메모리 기준에선, 다른 메모리 주소를 알고 있는 하나의 객체입니다.<br /></p>
<h3 id="잠깐-포인터에-대한-설명을-쉽게-해보겠습니다">잠깐, 포인터에 대한 설명을 쉽게 해보겠습니다.<br /></h3>
<p>컴퓨터상의 모든 값은 메모리의 주소를 가집니다.</p>
<h1 id="nodes와-관련된-구조들">Nodes와 관련된 구조들</h1>
<p>Nodes와 관련된 자료구조들은 사실 너무도 많습니다.<br />
사실 모든 구조가 계속 내려가면 Nodes 또는 Array로 되어 있기 떄문입니다.<br />
그 중에서 대표적인 것을 뽑자면 <strong>Binary search tree, Trie</strong>정도가 있습니다.<br /></p>
<p>중요한 건 Nodes 구조들은 <strong>포인터를 이용한 접근과 자료구조 변형이 잦은 구조들</strong>이라는 것입니다.<br />
즉, <strong>연속적인 주소 접근은 보다는 비규칙적인 주소 접근과 잦은 Insert, Delete가 이루어 지는 구조들</strong>입니다.</p>
<p>이를 이해하면, 왜 많은 비선형 구조들(예: Tree, Trie)들이 Node로 이루어 질 수 밖에 없는지<br />
그냥 배웠기에 받아들이는 것이 아니라 자연스럽게 이해하실 수 있고 구현도 쉽게 할 수 있습니다.<br /></p>유정민자료구조들의 아버지뻘인 Nodes 구조란 무엇일까?카카오 페스티벌: 보행자 천국2020-06-03T00:00:00+00:002020-06-03T00:00:00+00:00https://biewoom.github.io/coding%20test/kakao%202017/2020/06/03/heavenOfpedestrian<blockquote>
<p>출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges<br /></p>
</blockquote>
<h1 id="핵심개념">핵심개념</h1>
<p>1.기본적인 modular arithmetic<br />
2.DP(dynamic programming)<br /></p>
<h1 id="팁">팁</h1>
<p>먼저, 답의 정확성에서 문제가 발생하시면 Modular arithmetic에서 실수가 없었는지 체크바랍니다.<br />
여기서 필요한 Modular arithmetic은 A%m = (B%m + C%m)%m 단, m = 20170805 입니다.<br /></p>
<p>두 번째로, DP의 아이디어가 중요합니다.<br />
이 문제는 2 * (m+1) * (n+1) 크기의 DP가 문제 풀기에 용이합니다.<br />
각각 +1을 하는 이유는 i == m-1 이나 j == n-1의 경우를 계산할 때 편하게 하기 위함입니다.<br /></p>
<p>DP에는 (a, b)의 형태로 a: 이전에서 가로 방향으로 온 경우 b: 이전에서 세로 방향으로 온 경우<br />
로 나누시고 CityMap을 값을 체크하시면서 DP 값들을 처리하시면 됩니다.<br /></p>
<h1 id="그림-설명">그림 설명</h1>
<p>각 DP의 값에는 이전에서 가로방향으로 들어온 경우와 세로 방향 들어온 경우로 나눕니다.<br /></p>
<h3 id="citymap이-0인-경우">CityMap이 0인 경우</h3>
<p><img src="/assets/images/PS/2017-kakao-festival/hop1.png" alt="image" /></p>
<ol>
<li>어떤 방향이든 상관없이 dp[1][i][j+1]으로 저장</li>
<li>어떤 방향이든 상관없이 dp[0][i+1][j]로 저장</li>
</ol>
<h3 id="citymap이-2인-경우">CityMap이 2인 경우</h3>
<p><img src="/assets/images/PS/2017-kakao-festival/hop2.png" alt="image" />
※그림에 DP값을 1로 잘못 적었습니다. 1->2로 생각하시고 봐주세요.</p>
<ol>
<li>Vertical하게 들어온 값은 오른쪽으로 dp[1][i][j+1]으로 저장</li>
<li>Horizontal하게 들어온 값은 밑으로 dp[0][i+1][j]으로 저장</li>
</ol>
<h3 id="citymap이-1인-경우">CityMap이 1인 경우</h3>
<p>그냥 CONTINUE<br /></p>
<h3 id="시간-효율성">시간 효율성</h3>
<p><strong>O(m * n * 2)</strong></p>
<h1 id="code">Code:</h1>
<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">java.util.*</span><span class="o">;</span>
<span class="kd">class</span> <span class="nc">Solution</span> <span class="o">{</span>
<span class="kd">static</span> <span class="kd">final</span> <span class="kt">int</span> <span class="no">MOD</span> <span class="o">=</span> <span class="mi">20170805</span><span class="o">;</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">int</span> <span class="nf">solution</span><span class="o">(</span><span class="kt">int</span> <span class="n">m</span><span class="o">,</span> <span class="kt">int</span> <span class="n">n</span><span class="o">,</span> <span class="kt">int</span><span class="o">[][]</span> <span class="n">cityMap</span><span class="o">)</span> <span class="o">{</span>
<span class="kt">int</span><span class="o">[][][]</span> <span class="n">dp</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">int</span><span class="o">[</span><span class="mi">2</span><span class="o">][</span><span class="n">m</span> <span class="o">+</span> <span class="mi">1</span><span class="o">][</span><span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="o">];</span>
<span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="mi">0</span><span class="o">][</span><span class="mi">0</span><span class="o">]</span> <span class="o">=</span> <span class="mi">1</span><span class="o">;</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">n</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span> <span class="o">{</span>
<span class="k">if</span> <span class="o">(</span><span class="n">cityMap</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">==</span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
<span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">=</span> <span class="o">(</span><span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">+</span> <span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">+</span> <span class="n">dp</span><span class="o">[</span><span class="mi">1</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">])</span> <span class="o">%</span> <span class="no">MOD</span><span class="o">;</span>
<span class="n">dp</span><span class="o">[</span><span class="mi">1</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span> <span class="o">+</span> <span class="mi">1</span><span class="o">]</span> <span class="o">=</span> <span class="o">(</span><span class="n">dp</span><span class="o">[</span><span class="mi">1</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span> <span class="o">+</span> <span class="mi">1</span><span class="o">]</span> <span class="o">+</span> <span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">+</span> <span class="n">dp</span><span class="o">[</span><span class="mi">1</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">])</span> <span class="o">%</span> <span class="no">MOD</span><span class="o">;</span>
<span class="o">}</span> <span class="k">else</span> <span class="k">if</span> <span class="o">(</span><span class="n">cityMap</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">==</span> <span class="mi">2</span><span class="o">)</span> <span class="o">{</span>
<span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">=</span> <span class="o">(</span><span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">+</span> <span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">])</span> <span class="o">%</span> <span class="no">MOD</span><span class="o">;</span>
<span class="n">dp</span><span class="o">[</span><span class="mi">1</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span> <span class="o">+</span> <span class="mi">1</span><span class="o">]</span> <span class="o">=</span> <span class="o">(</span><span class="n">dp</span><span class="o">[</span><span class="mi">1</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span> <span class="o">+</span> <span class="mi">1</span><span class="o">]</span> <span class="o">+</span> <span class="n">dp</span><span class="o">[</span><span class="mi">1</span><span class="o">][</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">])</span> <span class="o">%</span> <span class="no">MOD</span><span class="o">;</span>
<span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
<span class="o">;</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="k">return</span> <span class="o">(</span><span class="n">dp</span><span class="o">[</span><span class="mi">0</span><span class="o">][</span><span class="n">m</span> <span class="o">-</span> <span class="mi">1</span><span class="o">][</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="o">]</span> <span class="o">+</span> <span class="n">dp</span><span class="o">[</span><span class="mi">1</span><span class="o">][</span><span class="n">m</span> <span class="o">-</span> <span class="mi">1</span><span class="o">][</span><span class="n">n</span> <span class="o">-</span> <span class="mi">1</span><span class="o">])</span> <span class="o">%</span> <span class="no">MOD</span><span class="o">;</span>
<span class="o">}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="nc">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
<span class="nc">Scanner</span> <span class="n">sc</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Scanner</span><span class="o">(</span><span class="nc">System</span><span class="o">.</span><span class="na">in</span><span class="o">);</span>
<span class="kt">int</span> <span class="n">m</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">());</span>
<span class="kt">int</span> <span class="n">n</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">());</span>
<span class="kt">int</span><span class="o">[][]</span> <span class="n">cityMap</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">int</span><span class="o">[</span><span class="n">m</span><span class="o">][</span><span class="n">n</span><span class="o">];</span>
<span class="nc">String</span> <span class="n">line</span> <span class="o">=</span> <span class="n">sc</span><span class="o">.</span><span class="na">nextLine</span><span class="o">();</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">lines</span> <span class="o">=</span> <span class="n">line</span><span class="o">.</span><span class="na">substring</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="n">line</span><span class="o">.</span><span class="na">length</span><span class="o">()</span> <span class="o">-</span> <span class="mi">1</span><span class="o">).</span><span class="na">split</span><span class="o">(</span><span class="s">"\\],\\["</span><span class="o">);</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">m</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
<span class="nc">String</span><span class="o">[]</span> <span class="n">newLine</span> <span class="o">=</span> <span class="n">lines</span><span class="o">[</span><span class="n">i</span><span class="o">].</span><span class="na">split</span><span class="o">(</span><span class="s">", "</span><span class="o">);</span>
<span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">n</span><span class="o">;</span> <span class="n">j</span><span class="o">++)</span> <span class="o">{</span>
<span class="n">cityMap</span><span class="o">[</span><span class="n">i</span><span class="o">][</span><span class="n">j</span><span class="o">]</span> <span class="o">=</span> <span class="nc">Integer</span><span class="o">.</span><span class="na">parseInt</span><span class="o">(</span><span class="n">newLine</span><span class="o">[</span><span class="n">j</span><span class="o">]);</span>
<span class="o">}</span>
<span class="o">}</span>
<span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">solution</span><span class="o">(</span><span class="n">m</span><span class="o">,</span> <span class="n">n</span><span class="o">,</span> <span class="n">cityMap</span><span class="o">));</span>
<span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>유정민2017-카카오 페스티벌-100% 풀이Linked List: Nodes 구조의 기본2020-04-25T00:00:00+00:002020-04-25T00:00:00+00:00https://biewoom.github.io/linear%20ds/nodes%20ds/2020/04/25/linked-list<h1 id="linked-list의-기능">Linked-list의 기능</h1>
<h1 id="실제-언어와-구현된-library">실제 언어와 구현된 Library</h1>
<p>※ Linked List를 구현한 라이브러리입니다.<br /></p>
<p><strong>Python:</strong> 표준 라이브러리 Collections의 deque가 Double-Linked-list로 되어있습니다.<br />
<strong>C++:</strong> STL의 list와 front-list가 내부적으로 Linked-list로 되어있습니다.<br />
<strong>Java:</strong> java.util.LinkedList가 내부적으로 Linked-list로 되어있습니다.<br /></p>
<h1 id="직접-구현-코드">직접 구현 코드</h1>
<p>Python: <a href="https://github.com/Biewoom/ds/blob/master/LinearDs/LinkedList.py">Github 코드 보러가기</a><br /></p>유정민가장 기본이 되는 Nodes 구조인 Linked-list에 대해서 알아보자.Dynamic Array: Array구조의 기본2020-04-24T00:00:00+00:002020-04-24T00:00:00+00:00https://biewoom.github.io/linear%20ds/array%20ds/basic%20ds/2020/04/24/Dynamic-array<h1 id="dynamic-array의-기능">Dynamic-Array의 기능</h1>
<p>Dynamic Array는 아래의 기능들을 수행할 수 있어야 합니다.<br /></p>
<ol>
<li>Initialize</li>
<li>Insert</li>
<li>Read</li>
<li>Update</li>
<li>Delete</li>
<li>Resize</li>
</ol>
<h3 id="initialize">Initialize</h3>
<p>DynamicArray는 내부 attribute로 할당받은 Heap 주소와 capcity, size를 가집니다.<br />
가장 처음에는 자료형*Capacity 만큼의 heap을 할당받아야 합니다.<br />
이 때, 내부적으로는 요청하는 크기만큼 Heap의 <strong>연속적인 배열</strong>을 할당을 해줍니다.<br /></p>
<h3 id="insert">Insert</h3>
<p>Dynamic array에서의 Insert는 두 가지 경우로 나눌 수 있습니다.<br />
<1> Array의 끝 부분에 Inert하는 경우 <2> Array의 중간부분에 Insert 하는 경우<br /></p>
<p>1번의 경우에는 size를 1만큼 늘리고, 끝 부분 값에 새로 넣는 값으로 Update를 하면 됩니다.<br />
따라서, 시간효율성은 O(1)인 Constant하게 이루어 질 수 있습니다.<br /></p>
<p>하지만, 2번 경우처럼 Array 중간에 Insert하는 경우 <strong>배열 주소값의 연속성을 유지</strong>하기 위해서는 <br />
새로운 Array를 만들어야 합니다.<br /> 이는 heap을 새로 할당받고 Copy하는 과정을 거쳐야합니다.<br />
따라서, O(n)의 시간 효율성을 요구받게 됩니다.<br /></p>
<h3 id="read">Read</h3>
<p><strong>Dynamic-array의 강점이 두드러지는 Action입니다.</strong><br />
배열의 연속성을 이용하여 우리가 원하는 Index의 값으로 <strong>Random Access</strong>할 수 있습니다. <br />
이 때 시간효율성은 O(1)로 Constant하게 접근할 수 있습니다.<br />
※많은 언어에서는 “[]” 기호로 접근할 수 있게 Indexing을 구현해놓았습니다.<br /></p>
<h3 id="update">Update</h3>
<p><strong>Dynamic-array의 강점이 두드러지는 Action입니다.</strong><br />
Update은 바로 위에서 언급한 Read의 action 후에 그 값을 수정하는 Action입니다.<br />
시간 효율성은 O(1)로 수행할 수 있고, 구현도 Read 부분과 크게 다른 게 없습니다.<br /></p>
<h3 id="delete">Delete</h3>
<p>Dyanamic array에서 delete를 하는 경우는 크게 두 가지로 나눌 수 있습니다.<br />
<1> Array의 끝 부분을 Delete하는 경우 <2> Array의 중간 부분을 Delete 하는 경우<br /></p>
<p>1번 경우에는 size를 1만큼 줄이고 마지막을 None 등의 값들로 다시 처리하면 됩니다.<br />
따라서, 시간효율성을 O(1)로 구현이 가능합니다.<br /></p>
<p>하지만, 2번처럼 Array의 중간을 Delete하는 경우 <strong>배열 주소값의 연속성을 유지하기</strong>위해서<br />
우리는 새로운 Array를 만들고 heap을 할당받고 copy를 하는 과정을 거쳐야합니다.<br />
따라서, O(n)의 시간 효율성을 요구받게 됩니다.<br /></p>
<h3 id="resize">Resize</h3>
<p>Static array가 아닌 Dynamic array만의 특징입니다.<br />
사실 내부 구조는 둘 다 같습니다. 다만, 후자는 Resize를 한다가 차이점입니다.<br />
이렇게 Resize를 하는 경우는 아래와 같은 두 가지 경우 입니다.<br /></p>
<p><strong>1. Insert로 인해, 현재의 Capacity보다 Array의 size가 커지려고 할 때</strong><br />
기존의 Capacity보다 size가 커지면, 더 이상 input을 넣을 공간이 부족하게 됩니다.<br />
이 때, 내부적으로 통상적으로 Capacity의 두 배정도의 새로운 Heap 공간을 요구합니다.<br />
그런 다음, 새롭게 할당받은 heap 공간에 현재의 값들을 모두 Copy합니다.<br />
기존에 있던 heap을 해제, 반환을 합니다.<br /></p>
<p><strong>2. Delete로 인해, 현재의 Capcity보다 Array이 현재 Size가 턱없이 작을 때</strong><br />
현재 쓰고 있는 10밖에 안되는데, 전체 메모리는 100을 할당받고 있으면 비효울적입니다.<br />
따라서, Delete로 인해 size가 많이 작아지면 통상적으로 반을 다시 반환을 해야 합니다.<br /></p>
<p>두 가지 모두 O(n)의 시간이 걸리지만, 실제로 Resize는 매번 요구받지는 않습니다.<br />
따라서 전체 시간효율성에는 큰 변화가 없습니다.<br /></p>
<h1 id="실제-언어와-구현된-library">실제 언어와 구현된 Library</h1>
<p>※ Dynamic Array를 구현한 라이브러리 입니다.<br /></p>
<p><strong>Python:</strong> 기본 구조형 List[]가 내부적으로 Dynamic Array로 되어 있습니다.<br />
<strong>C++:</strong> STL의 Vector가 내부적으로 Dynamic Array로 되어 있습니다.<br />
<strong>Java:</strong> java.util.ArrayList가 내부적으로 Dynamic Array로 되어 있습니다.<br /></p>
<h1 id="직접-구현-코드">직접 구현 코드</h1>
<p>Python: <a href="https://github.com/Biewoom/ds/blob/master/LinearDs/DynamicArray.py">Github 코드 보러가기</a><br /></p>유정민가장 기본이 되는 Array 구조인 Dynamic-array 에 대해서 알아보자.BitMask:Bit 인원보고 하겠습니다!2020-04-20T00:00:00+00:002020-04-20T00:00:00+00:00https://biewoom.github.io/misc/basic-algo/2020/04/20/bit-mask<p>우리가 군대의 점호시간에 현재 부대원을 보고함으로서, 현재 상태를 나타내듯이<br />
프로그램을 구현 하는 과정 중, 많은 부분에서 현재 상태를 체크하고 보고하는 일이<br />
많습니다. <strong>Bit를 이용한 BitMask로 상태를 표시</strong>하면 효율적일 때가 많습니다.<br />
이 글에서는 <strong>BitMask가 무엇인지? 어떻게 쓰이는 지에 대해서 알아보겠습니다.</strong><br /></p>
<h1 id="bit의-마법">Bit의 마법:</h1>
<p>많은 분들이 이미 아는 것처럼, 컴퓨터는 모든 것이 이진법으로 이루어져 있습니다.<br />
10(decimal) = 1010(bin), 4(decimal) = 10(bin), 13(decimal) = 1101(bin)처럼<br />
숫자의 경우, 컴퓨터는 우리의 십진법 숫자를 이진법 숫자로 바꾸어 해석합니다. <br /></p>
<!-- 그럼 컴퓨터는 왜 이진법을 사용할까요??<br/>
그 이유는 **컴퓨터는 전자를 이용한 기계이기 때문입니다.**<br/>
더 말하면, 전자가 들어오면: 1 전자가 나가면: 0 처럼 신호로 인식하도록 설계되었죠.<br/>
전자 회로는 이 전자들의 신호들을 이용해 메모리로 만들고, CPU를 만드는 것입니다.<br/> -->
<p>위 같은 사실은 우리가 “오호 2진법이군!”만 하고 넘어갈 것이 아니라<br />
우리의 알고리즘에도 이 Bit성질을 적용할 수 있고 실제 구현에서도 자주 이용합니다.<br />
BitMask란 ‘<strong>bit를 이용해 우리의 얼굴(mask)처럼 현재 상태를 표현한다.</strong>‘로 이해하면 됩니다.<br />
아래에서는 이 bit 성질을 이용한 BitMask의 기능에 대해서 알아보겠습니다.<br /></p>
<blockquote>
<p>ALU의 회로나 CPU구조를 아신다면 더 깊은 이해가 됩니다.</p>
</blockquote>
<h1 id="어떤-기능을-할-수-있는가">어떤 기능을 할 수 있는가?</h1>
<p>BitMask는 <strong>현재 상태를 표현, 변형 또는 비교 등의 기능을 수행 할 수 있습니다.</strong><br />
이 상태를 변형하거나 비교는 <strong>Bitwise함수를 이용하게 되는 경우가 많습니다.</strong><br /></p>
<p><strong>Bitwise함수를 이용하는 이유는 이 함수들은 ALU 안의 OR 또는 AND Gate 등을 활용해</strong><br />
<strong>각 bit 단위 연산을 CPU에서 한 번에 계산하여, 효율성을 훨씬 높일 수 있기 때문입니다.</strong><br /></p>
<blockquote>
<p><a href="">BitWise 함수 알아보기</a></p>
</blockquote>
<p>BitMask의 기능들은 아래의 문제와 함께 설명을 하겠습니다.<br /></p>
<h1 id="문제-제시">문제 제시</h1>
<p>한 반에 학생 세 명이 있습니다. 어느 날 이 반에서 깜짝 조별 시험을 치기로 하였습니다.<br />
시험에서 요구하는 건 ‘국영수사과’ 로 5개 과목이고, 오픈북 시험을 치기로 하였습니다.<br />
시험은 쉬워서, 교과서만 있다면 학생은 과목에 해당되는 문제는 다 맞을 수 있습니다.<br />
하지만 어떤 과목에 해당되는 교과서가 없다면 학생은 틀리게 될 것 입니다.<br />
최대 두 명까지 조를 짤수 있습니다.<br /></p>
<p><img src="/assets/images/algo/misc/bit-mask/problem.png" alt="image" /></p>
<p>위는 학생들의 가방과 가방 안에 있는 교과서들입니다.<br />
<strong>어떤 학생과 어떤 학생이 조를 짜야지 무조건 백점을 맞는 조가 나올 수 있을까요?</strong><br />
<strong>어떻게 하면 위의 답을 효율적으로 구할 수 있을까요?</strong><br /></p>
<h1 id="주먹구구식-방법">주먹구구식 방법:</h1>
<p>가장 쉬운 방법으로는 <strong>만들 수 있는 모든 조를 짜보고 조건이 맞는 지 확인하는 것입니다.</strong><br />
조건이 맞다는 것은 <strong>각각 만든 조가 모든 교과서를 가지고 있는 지를 확인하는 것입니다.</strong><br /></p>
<p>확인 하는 방법은 <strong>조원의 가방 안에 교과서들을 다 모아놓고 하나씩 체크하는 것입니다.</strong><br />
요약하면 문제 푸는 과정은 아래의 두 과정입니다.<br /></p>
<ol>
<li>랜덤하게 두 학생을 뽑아서 그룹을 만든다.</li>
<li>만든 그룹 안의 책들을 모아서 체크하고, 모든 종류의 책이 있는지 확인한다.</li>
</ol>
<p>문제를 푸는 일련의 과정은 아래와 같습니다.<br /></p>
<ol>
<li>학생1과 학생 2과 그룹을 이루는 경우
<img src="/assets/images/algo/misc/bit-mask/brute-force1.png" alt="image" /></li>
</ol>
<p>위처럼 그룹을 만들고, 만든 그룹의 책들을 모두 모아 체크하면 아래와 같습니다.</p>
<p><img src="/assets/images/algo/misc/bit-mask/brute-force1-check.png" alt="image" /></p>
<p>체크 결과는 <strong>사회책이 없어서 이 그룹은 백점을 맞기 힘든 그룹이라는 결과가 나옵니다.</strong><br />
따라서 다른 그룹을 만들고 위처럼 체크를 합니다.<br /></p>
<ol>
<li>학생2와 학생 3이 그룹을 이루는 경우
<img src="/assets/images/algo/misc/bit-mask/brute-force2.png" alt="image" /></li>
</ol>
<p>위처럼 그룹을 만들고, 만든 그룹의 책들을 모두 모아 체크하면 아래와 같습니다.</p>
<p><img src="/assets/images/algo/misc/bit-mask/brute-force2-check.png" alt="image" /></p>
<p>체크 결과는 <strong>과학책이 없어서 이 그룹은 백점을 맞기 힘든 그룹이라는 결과가 나옵니다.</strong><br />
따라서 다른 그룹을 만들고 위처럼 체크를 합니다.<br /></p>
<ol>
<li>학생1과 학생 3이 그룹을 이루는 경우
<img src="/assets/images/algo/misc/bit-mask/brute-force3.png" alt="image" /></li>
</ol>
<p>위처럼 그룹을 만들고, 만든 그룹의 책들을 모두 모아 체크하면 아래와 같습니다.</p>
<p><img src="/assets/images/algo/misc/bit-mask/brute-force3-check.png" alt="image" /></p>
<p>체크 결과는 <strong>모든 교과서가 있어서 백점을 맞을 수 있는 그룹이다</strong>라는 결과가 나옵니다.<br />
따라서 그룹을 만드는 것을 멈추고 <strong>학생1-학생3 그룹이라는 답을 구할 수 있습니다.</strong><br /></p>
<p><strong>평가:</strong><br />
최악의 경우, 그룹 짜는 모든 경우의 수를 고려하는 것은 피할 수 없습니다.<br />
따라서 그룹을 만드는 시간 효율성은 O( (N*N-1)/2 )입니다.<br />
(이 때, N = 학생의 수 이고 위 식은 N개에서 2개를 뽑는 경우와 같습니다.)</p>
<p>그룹을 만드는 것뿐만 아니라, <strong>매번 그룹의 교과서를 모아서 체크도 해야 합니다.</strong><br />
<strong>이 경우의 수는 O(2 * M) (이 떄, M = 학생 가방 안에 있는 교과서 수)입니다.</strong><br />
따라서 위 값들을 곱해서 나온 전체 시간효율성은 O((N * N-1)* M)입니다.<br /></p>
<p>위 두 가지 과정 중 <strong>교과서를 다 모아서 검사하는 과정은 BitMasks와</strong><br />
<strong>Bitwise 함수들을 이용하면 이전보다 훨씬 효율적으로 수행할 수 있습니다.</strong><br /></p>
<h1 id="bitmask">BitMask</h1>
<p>위 문제에서 BitMask의 아이디어는 다음과 같습니다.<br />
<strong>학생의 가방 상태를 5개의 bit로 생각하고, 각 bit는 책의 유/무를 알려주면 되지 않을까?</strong><br />
이 아이디어는 그림으로 표현하면 아래와 같습니다.<br /></p>
<p><img src="/assets/images/algo/misc/bit-mask/bitMask.png" alt="image" /></p>
<p>위 아이디어를 이용해서 각각 학생들의 가방의 책 상태를 표시하면 아래와 같습니다.<br />
※ 괄호 안의 값은 십진법으로 나타낸 수 입니다.</p>
<p><img src="/assets/images/algo/misc/bit-mask/bitmask1.png" alt="image" /></p>
<p>위처럼 bitmask를 이용하면 각 학생의 가방 상태를 5개의 bit로 나타낼 수 있습니다.<br />
또한, 그룹을 만든 후의 그룹의 책의 상태는 <strong>OR을 이용하면</strong> 쉽게 구할 수 있습니다.<br />
※ <strong>백 점을 맞는 조는 모든 책이 있는 상태로, Bitmask로 나타내면 ‘11111’입니다.</strong><br /></p>
<p>BitMask를 이용한 풀이의 일련의 과정은 아래와 같습니다.</p>
<ol>
<li>학생 1과 학생 2가 그룹을 이루는 경우
<img src="/assets/images/algo/misc/bit-mask/bitmask-or1.png" alt="image" /></li>
</ol>
<p><strong>위 그룹의 책 상태는 ‘11101’으로 4번째 bit가 나타내는 사회책이 없어 답이 될 수 없습니다.</strong><br />
따라서 다른 그룹을 만들고 위처럼 체크를 합니다.<br /></p>
<ol>
<li>학생 2와 학생 3이 그룹을 이루는 경우
<img src="/assets/images/algo/misc/bit-mask/bitmask-or2.png" alt="image" /></li>
</ol>
<p><strong>위 그룹의 책 상태는 ‘11110’으로 5번째 bit가 나타내는 과학책이 없어 답이 될 수 없습니다.</strong><br />
따라서 다른 그룹을 만들고 위처럼 체크를 합니다.<br /></p>
<ol>
<li>학생 1와 학생 3이 그룹을 이루는 경우
<img src="/assets/images/algo/misc/bit-mask/bitmask-or3.png" alt="image" /></li>
</ol>
<p><strong>위 그룹의 책 상태는 ‘11111’, 즉 모든 책이 있는 상태이고 따라서 우리가 찾는 답입니다.</strong><br />
따라서 다른 그룹을 만드는 걸 멈추고 답을 도출합니다.<br /></p>
<h1 id="bitmask-평가">BitMask 평가:</h1>
<p>처음의 주먹구구식 방법과는 다르게 data-preprocessing 시간이 걸립니다.<br />
이유는 기존의 list 형태로 받은 책들을 가방의 bitMask로 바꿔야 하기 때문이죠.<br /></p>
<p>하지만 그 후에 그룹의 상태를 얻을 때는 이전에 O(2 * M)의 시간이 걸렸던 것과<br />
다르게, <strong>O(1)로 가능합니다. Or operater을 사용해서 모든 책 유무를 한 번에</strong><br />
<strong>비교하고 그룹의 상태를 얻는 것이 가능하기 때문입니다.</strong><br /></p>
<p>전체 시간효율성은 모든 그룹을 만드는 경우인 O((N * N-1)/ 2)입니다.<br /></p>
<p><strong>한계점:</strong><br />
이 문제처럼 유/무 처럼 0과 1로만 상태 표현이 가능하면 BitMask가 효과적입니다.<br />
그러나 만약 ‘책은 있지만 반이 찢어진 상태’, ‘책은 있지만 1/4만 있는 상태’처럼<br />
0과 1로 책의 상태를 설명하지 못하는 경우가 있다면, 조금 복잡해 집니다.<br /></p>
<p>이를 해결하기 위해 n개의 bit를 하나로 묶어 책 상태를 표현할 수 있습니다.<br />
하지만, <strong>고려 해야할 상태가 많은 경우에는 이 과정에서 비효율성이 일어날 수 있습니다.</strong><br /></p>
<h1 id="구현-by-python">구현 by Python</h1>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">os</span>
<span class="kn">import</span> <span class="nn">sys</span>
<span class="k">def</span> <span class="nf">makeBitMask</span><span class="p">(</span><span class="n">student</span><span class="p">):</span> <span class="c1"># Bitmask 만들기
</span> <span class="n">bitmask</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">if</span> <span class="s">'국어'</span> <span class="ow">in</span> <span class="n">student</span><span class="p">:</span> <span class="n">bitmask</span> <span class="o">|=</span> <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">4</span><span class="p">)</span>
<span class="k">if</span> <span class="s">'영어'</span> <span class="ow">in</span> <span class="n">student</span><span class="p">:</span> <span class="n">bitmask</span> <span class="o">|=</span> <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">3</span><span class="p">)</span>
<span class="k">if</span> <span class="s">'수학'</span> <span class="ow">in</span> <span class="n">student</span><span class="p">:</span> <span class="n">bitmask</span> <span class="o">|=</span> <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">2</span><span class="p">)</span>
<span class="k">if</span> <span class="s">'사회'</span> <span class="ow">in</span> <span class="n">student</span><span class="p">:</span> <span class="n">bitmask</span> <span class="o">|=</span> <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span> <span class="s">'과학'</span> <span class="ow">in</span> <span class="n">student</span><span class="p">:</span> <span class="n">bitmask</span> <span class="o">|=</span> <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">0</span><span class="p">)</span>
<span class="k">return</span> <span class="n">bitmask</span>
<span class="k">def</span> <span class="nf">solve</span><span class="p">(</span><span class="n">student_list</span><span class="p">):</span> <span class="c1"># 문제 풀이
</span>
<span class="n">bitmask_list</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">student</span> <span class="ow">in</span> <span class="n">student_list</span><span class="p">:</span> <span class="n">bitmask_list</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">makeBitMask</span><span class="p">(</span><span class="n">student</span><span class="p">))</span> <span class="c1">#data-PreProcessing
</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">bitmask_list</span><span class="p">)):</span> <span class="c1">#그룹 만들고 비교
</span> <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">bitmask_list</span><span class="p">)):</span>
<span class="k">if</span> <span class="n">bitmask_list</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">|</span><span class="n">bitmask_list</span><span class="p">[</span><span class="n">j</span><span class="p">]</span> <span class="o">==</span> <span class="p">(</span><span class="mi">1</span><span class="o"><<</span><span class="mi">5</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">return</span> <span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">)</span> <span class="c1"># 답 도출
</span></code></pre></div></div>유정민Bits와 Bitwise 함수를 사용해서 현재 상태를 나타내는 법을 알아보자.카카오 테스트:기둥과 보 설치2020-04-20T00:00:00+00:002020-04-20T00:00:00+00:00https://biewoom.github.io/coding%20test/kakao%202020%20blind/2020/04/20/pillar<blockquote>
<p>출처: 프로그래머스 코딩 테스트 연습, https://programmers.co.kr/learn/challenges<br /></p>
</blockquote>
<p>이 문제는 문제의 효율성 고려나 어려운 개념을 요구하는 게 아니라<br />
주어진 복잡한 instructions을 코드로 구현 할 수 있는 지를 묻는 문제입니다.<br />
따라서 전체과정을 도식화하는 능력과 깔끔한 코드를 짜는게 핵심이라고 생각합니다.<br /></p>
<h1 id="핵심-개념">핵심 개념:</h1>
<ol>
<li><a href="/misc/basic-algo/2020/04/17/matrix-rotation.html">Matrix rotation</a></li>
<li><a href="/misc/basic-algo/2020/04/20/bit-mask.html">BitMask</a></li>
</ol>
<h1 id="tip">TIP:</h1>
<p>첫 번째, 적당한 Matrix rotation를 이용해서 문제에서 주어지는 Matrix의 좌표를<br />
우리가 평소에 사용하는 Matrix의 좌표로 바꾸어 놓고, 문제를 생각하면 좀 더 수월합니다.<br />
몇 가지의 경우를 종이에 적어보시면, 어떻게 치환 할 지 패턴이 보이실 겁니다.<br />
Ex) n = 5일떄, (0,0) -> (5,0), (0,3) -> (2, 0), (3,4) -> (1, 3)<br />
※ 앞: 문제에서 주어진 좌표, 뒤: 우리가 실제 사용할 좌표<br /></p>
<p>두 번째, Bit maninpuation을 이용하면, 설치, 삭제 또는 현재 상태까지 나타낼 수 있습니다.<br />
OR: 설치, XOR: 삭제, xxxx: 앞에 두 개의 digit은 기둥의 상태, 뒤에 두 개의 digits은 보의 상태<br />
1: 있다 0: 없다로 생각하고 아래와 같이 생각하면 편합니다.<br />
Ex) 0000: 아무것도 없다, 1000: 기둥 아랫부분만 있다. ,1100: 기둥 아랫부분 과 기둥 윗부분이 있다.<br />
1011: 기둥 아랫부분 과 보의 왼쪽과 보의 오른쪽이 있다., 0001: 보의 오른쪽만 있다.<br /></p>
<p>마지막으로, 이 문제는, 설치보단 삭제 부분이 조금 까다롭습니다.<br />
혹시 테스트가 13번 이후로 다 틀린다면, 삭제 부분에서 문제가 있을 확률이 큽니다.<br /></p>
<h1 id="풀이법">풀이법</h1>
<p>저 같은 경우 이걸 아래와 같은 과정을 도식화하여 풀었습니다.<br />
워낙 코드가 길어, 제 코드 리딩은 도움이 안될 거 같습니다.</p>
<ol>
<li>삭제할 좌표에 실제로 보 또는 기둥이 존재하는 지 판단 (없을시 return)</li>
<li>일단 삭제한다고 가정</li>
<li>영향을 끼칠 좌표들의 유효성 검사</li>
<li>영향을 끼칠 좌표들이 모두 유효하다면 삭제 그대로 진행</li>
<li>하나라도 유효하지 않으면, 다시 삭제했던 구조물 재설치</li>
</ol>
<h1 id="구현-by-python">구현 by Python</h1>
<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kn">import</span> <span class="nn">os</span>
<span class="kn">import</span> <span class="nn">sys</span>
<span class="k">def</span> <span class="nf">pillar_alive</span><span class="p">(</span><span class="n">coord</span><span class="p">,</span> <span class="n">matrix</span><span class="p">):</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">coord</span>
<span class="n">pillar_start</span><span class="p">,</span> <span class="n">pillar_end</span><span class="p">,</span> <span class="n">bar_start</span><span class="p">,</span> <span class="n">bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">])</span>
<span class="k">if</span> <span class="n">pillar_end</span> <span class="ow">or</span> <span class="n">bar_start</span> <span class="ow">or</span> <span class="n">bar_end</span><span class="p">:</span> <span class="k">return</span> <span class="bp">True</span>
<span class="k">else</span><span class="p">:</span> <span class="k">return</span> <span class="bp">False</span>
<span class="k">def</span> <span class="nf">bar_alive</span><span class="p">(</span><span class="n">coord</span><span class="p">,</span> <span class="n">matrix</span><span class="p">,</span> <span class="n">ttype</span><span class="p">):</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">coord</span>
<span class="n">C_pillar_start</span><span class="p">,</span> <span class="n">C_pillar_end</span><span class="p">,</span> <span class="n">C_bar_start</span><span class="p">,</span> <span class="n">C_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">])</span>
<span class="k">if</span> <span class="n">ttype</span> <span class="o">==</span> <span class="s">'left'</span><span class="p">:</span>
<span class="n">L_pillar_start</span><span class="p">,</span> <span class="n">L_pillar_end</span><span class="p">,</span> <span class="n">L_bar_start</span><span class="p">,</span> <span class="n">L_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="o">-</span><span class="mi">1</span><span class="p">])</span>
<span class="k">if</span> <span class="n">C_pillar_end</span> <span class="ow">or</span> <span class="n">L_pillar_end</span><span class="p">:</span> <span class="k">return</span> <span class="bp">True</span>
<span class="k">elif</span> <span class="n">C_bar_start</span> <span class="ow">and</span> <span class="n">L_bar_end</span><span class="p">:</span> <span class="k">return</span> <span class="bp">True</span>
<span class="k">else</span><span class="p">:</span> <span class="k">return</span> <span class="bp">False</span>
<span class="k">elif</span> <span class="n">ttype</span> <span class="o">==</span> <span class="s">'right'</span><span class="p">:</span> <span class="c1"># given is start
</span> <span class="n">R_pillar_start</span><span class="p">,</span> <span class="n">R_pillar_end</span><span class="p">,</span> <span class="n">R_bar_start</span><span class="p">,</span> <span class="n">R_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">])</span>
<span class="k">if</span> <span class="n">C_pillar_end</span> <span class="ow">or</span> <span class="n">R_pillar_end</span><span class="p">:</span> <span class="k">return</span> <span class="bp">True</span>
<span class="k">elif</span> <span class="n">C_bar_end</span> <span class="ow">and</span> <span class="n">R_bar_start</span><span class="p">:</span> <span class="k">return</span> <span class="bp">True</span>
<span class="k">else</span><span class="p">:</span> <span class="k">return</span> <span class="bp">False</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s">'IMPOSSIBLE'</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">Checker</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="o">-></span> <span class="nb">list</span><span class="p">:</span>
<span class="c1">#result = [pillar's start, pillar's end, bar's start, bar's end]
</span> <span class="n">_bit</span> <span class="o">=</span> <span class="s">'{:04b}'</span><span class="p">.</span><span class="nb">format</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="n">_bit</span><span class="p">:</span>
<span class="k">if</span> <span class="n">_</span> <span class="o">==</span> <span class="s">'0'</span><span class="p">:</span> <span class="n">result</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="bp">False</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">_</span> <span class="o">==</span> <span class="s">'1'</span><span class="p">:</span> <span class="n">result</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="bp">True</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span> <span class="k">print</span><span class="p">(</span><span class="s">"Impossible: "</span><span class="p">,</span> <span class="n">_</span><span class="p">)</span>
<span class="k">return</span> <span class="n">result</span>
<span class="k">def</span> <span class="nf">CoordSwapper1</span><span class="p">(</span><span class="n">coord</span><span class="p">,</span> <span class="n">matrix</span><span class="p">):</span> <span class="c1"># problemSetting coord -> build_it coord
</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">coord</span>
<span class="n">swapped_x</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">matrix</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span> <span class="o">-</span> <span class="n">y</span>
<span class="n">swapped_y</span> <span class="o">=</span> <span class="n">x</span>
<span class="k">return</span> <span class="p">(</span><span class="n">swapped_x</span><span class="p">,</span> <span class="n">swapped_y</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">CoordSwapper2</span><span class="p">(</span><span class="n">coord</span><span class="p">,</span> <span class="n">matrix</span><span class="p">):</span> <span class="c1"># built_in coord -> problemSetting coord
</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">coord</span>
<span class="n">swapped_x</span> <span class="o">=</span> <span class="n">y</span>
<span class="n">swapped_y</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">matrix</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span> <span class="o">-</span> <span class="n">x</span>
<span class="k">return</span> <span class="p">(</span><span class="n">swapped_x</span><span class="p">,</span> <span class="n">swapped_y</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">remove_bar</span><span class="p">(</span><span class="n">coord</span><span class="p">,</span> <span class="n">matrix</span><span class="p">):</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">coord</span>
<span class="n">L_pillar_start</span><span class="p">,</span> <span class="n">L_pillar_end</span><span class="p">,</span> <span class="n">L_bar_start</span><span class="p">,</span> <span class="n">L_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">])</span>
<span class="n">R_pillar_start</span><span class="p">,</span> <span class="n">R_pillar_end</span><span class="p">,</span> <span class="n">R_bar_start</span><span class="p">,</span> <span class="n">R_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">])</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">L_bar_start</span><span class="p">:</span> <span class="k">return</span>
<span class="c1">#remove
</span> <span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">]</span><span class="o">^=</span> <span class="mi">2</span><span class="p">;</span> <span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">^=</span> <span class="mi">1</span>
<span class="n">L_pillar_TEST</span> <span class="o">=</span> <span class="bp">True</span> <span class="k">if</span> <span class="p">(</span><span class="ow">not</span> <span class="n">L_pillar_start</span><span class="p">)</span> <span class="ow">or</span> <span class="n">pillar_alive</span><span class="p">((</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span> <span class="k">else</span> <span class="bp">False</span>
<span class="n">R_pillar_TEST</span> <span class="o">=</span> <span class="bp">True</span> <span class="k">if</span> <span class="p">(</span><span class="ow">not</span> <span class="n">R_pillar_start</span><span class="p">)</span> <span class="ow">or</span> <span class="n">pillar_alive</span><span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span> <span class="k">else</span> <span class="bp">False</span>
<span class="n">L_bar_TEST</span> <span class="o">=</span> <span class="bp">True</span> <span class="k">if</span> <span class="p">(</span><span class="ow">not</span> <span class="n">L_bar_end</span><span class="p">)</span> <span class="ow">or</span> <span class="n">bar_alive</span><span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">,</span> <span class="s">'left'</span><span class="p">)</span> <span class="k">else</span> <span class="bp">False</span>
<span class="n">R_bar_TEST</span> <span class="o">=</span> <span class="bp">True</span> <span class="k">if</span> <span class="p">(</span><span class="ow">not</span> <span class="n">R_bar_start</span><span class="p">)</span> <span class="ow">or</span> <span class="n">bar_alive</span><span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">),</span> <span class="n">matrix</span><span class="p">,</span> <span class="s">'right'</span><span class="p">)</span> <span class="k">else</span> <span class="bp">False</span>
<span class="k">if</span> <span class="n">L_pillar_TEST</span> <span class="ow">and</span> <span class="n">R_pillar_TEST</span> <span class="ow">and</span> <span class="n">L_bar_TEST</span> <span class="ow">and</span> <span class="n">R_bar_TEST</span><span class="p">:</span> <span class="k">return</span>
<span class="k">else</span><span class="p">:</span> <span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">]</span><span class="o">|=</span> <span class="mi">2</span><span class="p">;</span> <span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">|=</span> <span class="mi">1</span> <span class="c1">#reinstall
</span>
<span class="k">def</span> <span class="nf">remove_pillar</span><span class="p">(</span><span class="n">coord</span><span class="p">,</span> <span class="n">matrix</span><span class="p">):</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">coord</span>
<span class="n">D_pillar_start</span><span class="p">,</span> <span class="n">D_pillar_end</span><span class="p">,</span> <span class="n">D_bar_start</span><span class="p">,</span> <span class="n">D_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">])</span>
<span class="n">U_pillar_start</span><span class="p">,</span> <span class="n">U_pillar_end</span><span class="p">,</span> <span class="n">U_bar_start</span><span class="p">,</span> <span class="n">U_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">][</span><span class="n">y</span><span class="p">])</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">D_pillar_start</span><span class="p">:</span> <span class="k">return</span>
<span class="c1">#remove
</span> <span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">]</span><span class="o">^=</span> <span class="mi">8</span><span class="p">;</span> <span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">][</span><span class="n">y</span><span class="p">]</span><span class="o">^=</span> <span class="mi">4</span>
<span class="n">U_pillar_TEST</span> <span class="o">=</span> <span class="bp">True</span> <span class="k">if</span> <span class="p">(</span><span class="ow">not</span> <span class="n">U_pillar_start</span><span class="p">)</span> <span class="ow">or</span> <span class="n">pillar_alive</span><span class="p">((</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="n">y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span> <span class="k">else</span> <span class="bp">False</span>
<span class="n">L_bar_TEST</span> <span class="o">=</span> <span class="bp">True</span> <span class="k">if</span> <span class="p">(</span><span class="ow">not</span> <span class="n">U_bar_end</span><span class="p">)</span> <span class="ow">or</span> <span class="n">bar_alive</span><span class="p">((</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="n">y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">,</span> <span class="s">'left'</span><span class="p">)</span> <span class="k">else</span> <span class="bp">False</span>
<span class="n">R_bar_TEST</span> <span class="o">=</span> <span class="bp">True</span> <span class="k">if</span> <span class="p">(</span><span class="ow">not</span> <span class="n">U_bar_start</span><span class="p">)</span> <span class="ow">or</span> <span class="n">bar_alive</span><span class="p">((</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="n">y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">,</span> <span class="s">'right'</span><span class="p">)</span> <span class="k">else</span> <span class="bp">False</span>
<span class="k">if</span> <span class="n">U_pillar_TEST</span> <span class="ow">and</span> <span class="n">L_bar_TEST</span> <span class="ow">and</span> <span class="n">R_bar_TEST</span><span class="p">:</span> <span class="k">return</span>
<span class="k">else</span><span class="p">:</span> <span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">]</span><span class="o">|=</span> <span class="mi">8</span><span class="p">;</span> <span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">][</span><span class="n">y</span><span class="p">]</span><span class="o">|=</span> <span class="mi">4</span> <span class="c1"># reinstall
</span>
<span class="k">def</span> <span class="nf">install_pillar</span><span class="p">(</span><span class="n">coord</span><span class="p">,</span> <span class="n">matrix</span><span class="p">):</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">coord</span>
<span class="n">pillar_start</span><span class="p">,</span> <span class="n">pillar_end</span><span class="p">,</span> <span class="n">bar_start</span><span class="p">,</span> <span class="n">bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">])</span>
<span class="k">if</span> <span class="n">x</span> <span class="o">==</span> <span class="nb">len</span><span class="p">(</span><span class="n">matrix</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span> <span class="ow">or</span> <span class="n">bar_start</span> <span class="ow">or</span> <span class="n">bar_end</span> <span class="ow">or</span> <span class="n">pillar_end</span><span class="p">:</span>
<span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">]</span> <span class="o">|=</span> <span class="mi">8</span>
<span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">][</span><span class="n">y</span><span class="p">]</span> <span class="o">|=</span> <span class="mi">4</span>
<span class="k">def</span> <span class="nf">install_bar</span><span class="p">(</span><span class="n">coord</span><span class="p">,</span> <span class="n">matrix</span><span class="p">):</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="o">=</span> <span class="n">coord</span>
<span class="n">L_pillar_start</span><span class="p">,</span> <span class="n">L_pillar_end</span><span class="p">,</span> <span class="n">L_bar_start</span><span class="p">,</span> <span class="n">L_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">])</span>
<span class="n">R_pillar_start</span><span class="p">,</span> <span class="n">R_pillar_end</span><span class="p">,</span> <span class="n">R_bar_start</span><span class="p">,</span> <span class="n">R_bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">])</span>
<span class="k">if</span> <span class="n">L_pillar_end</span> <span class="ow">or</span> <span class="n">R_pillar_end</span> <span class="ow">or</span> <span class="p">(</span><span class="n">L_bar_end</span> <span class="ow">and</span> <span class="n">R_bar_start</span><span class="p">):</span>
<span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">]</span> <span class="o">|=</span> <span class="mi">2</span>
<span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span> <span class="o">|=</span> <span class="mi">1</span>
<span class="k">def</span> <span class="nf">show_all</span><span class="p">(</span><span class="n">matrix</span><span class="p">,</span> <span class="n">res</span><span class="p">):</span>
<span class="n">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">matrix</span><span class="p">)</span>
<span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="k">for</span> <span class="n">y</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="n">pillar_start</span><span class="p">,</span> <span class="n">pillar_end</span><span class="p">,</span> <span class="n">bar_start</span><span class="p">,</span> <span class="n">bar_end</span> <span class="o">=</span> <span class="n">Checker</span><span class="p">(</span><span class="n">matrix</span><span class="p">[</span><span class="n">x</span><span class="p">][</span><span class="n">y</span><span class="p">])</span>
<span class="n">_x</span><span class="p">,</span> <span class="n">_y</span> <span class="o">=</span> <span class="n">CoordSwapper2</span><span class="p">(</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span>
<span class="k">if</span> <span class="n">pillar_start</span><span class="p">:</span> <span class="n">res</span><span class="p">.</span><span class="n">append</span><span class="p">([</span><span class="n">_x</span><span class="p">,</span><span class="n">_y</span><span class="p">,</span><span class="mi">0</span><span class="p">])</span>
<span class="k">if</span> <span class="n">bar_start</span><span class="p">:</span> <span class="n">res</span><span class="p">.</span><span class="n">append</span><span class="p">([</span><span class="n">_x</span><span class="p">,</span><span class="n">_y</span><span class="p">,</span><span class="mi">1</span><span class="p">])</span>
<span class="k">return</span>
<span class="k">def</span> <span class="nf">solution</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">build_frame</span><span class="p">):</span>
<span class="n">res</span> <span class="o">=</span> <span class="p">[];</span> <span class="n">matrix</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">0</span><span class="p">]</span><span class="o">*</span><span class="p">(</span><span class="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">)]</span>
<span class="k">for</span> <span class="n">op</span> <span class="ow">in</span> <span class="n">build_frame</span><span class="p">:</span>
<span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="n">op</span>
<span class="n">_x</span><span class="p">,</span> <span class="n">_y</span> <span class="o">=</span> <span class="n">CoordSwapper1</span><span class="p">((</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span>
<span class="k">if</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">b</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="n">remove_pillar</span><span class="p">((</span><span class="n">_x</span><span class="p">,</span><span class="n">_y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">and</span> <span class="n">b</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span> <span class="n">install_pillar</span><span class="p">((</span><span class="n">_x</span><span class="p">,</span><span class="n">_y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">1</span> <span class="ow">and</span> <span class="n">b</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="n">remove_bar</span><span class="p">((</span><span class="n">_x</span><span class="p">,</span><span class="n">_y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">a</span> <span class="o">==</span> <span class="mi">1</span> <span class="ow">and</span> <span class="n">b</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span> <span class="n">install_bar</span><span class="p">((</span><span class="n">_x</span><span class="p">,</span><span class="n">_y</span><span class="p">),</span> <span class="n">matrix</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span> <span class="k">print</span><span class="p">(</span><span class="s">"IMPOSSIBLE: "</span><span class="p">,</span> <span class="n">op</span><span class="p">)</span>
<span class="n">show_all</span><span class="p">(</span><span class="n">matrix</span><span class="p">,</span> <span class="n">res</span><span class="p">)</span>
<span class="n">res</span><span class="p">.</span><span class="n">sort</span><span class="p">()</span>
<span class="k">return</span> <span class="n">res</span>
</code></pre></div></div>유정민2020 카카오-채용 100% 친절 풀이