08
14

https://www.acmicpc.net/problem/12100

 

움직이는 횟수가 5회로 제한되어 결과를 확인하는 것이기 때문에 재귀를 사용하여 모든 경우의 수를 확인했다. 큐를 이용해 한줄을 입력받고 블록이 만나는지 칸이 비어있는지 등의 조건에 따라 값을 변화시켜 다시 원래의 칸에 넣는다.

 

using System;
using System.Collections;
using System.Collections.Generic;

namespace _12100
{
    class Program
    {
        public static int max_value = 0;
        public static int MapSize;
        public static int[,] Map = new int[20, 20];

        public static void Move(int[,] State, int count)
        {
            int[,] copy_state;
            

            if(count == 5)
            {
                for(int i = 0; i < MapSize;i++)
                {
                    for(int j= 0; j<MapSize;j++)
                    {
                        if(max_value < State[i,j])
                        {
                            max_value = State[i, j];
                        }
                    }
                }
                return;
            }

            Queue<int> inputQ = new Queue<int>();
            Queue<int> resultQ = new Queue<int>();
            List<int> list = new List<int>();
            //위로 이동
            copy_state = (int[,])State.Clone();
            for(int i = 0; i < MapSize; i++)
            {
                // 가지고 있는 블럭 정보를 큐에 저장
                for(int j = 0; j < MapSize; j++)
                {
                    inputQ.Enqueue(copy_state[j, i]);
                }

                // 큐의 정보를 바탕으로 위로 이동하는 것을 계산
                int num = -1;
                while(true)
                {
                    if(num == -1)
                    {
                        num = inputQ.Dequeue();
                    }

                    if (inputQ.Count == 0)
                    {
                        resultQ.Enqueue(num);
                        break;
                    }

                    if (num == 0)
                    {
                        num = num + inputQ.Dequeue();
                        if (inputQ.Count == 0)
                        {
                            resultQ.Enqueue(num);
                            break;
                        }
                    }
                    else
                    {
                        if (inputQ.Peek() == 0)
                        {
                            inputQ.Dequeue();
                            if (inputQ.Count == 0)
                            {
                                resultQ.Enqueue(num);
                                break;
                            }

                        }
                        else if (inputQ.Peek() != num)
                        {
                            resultQ.Enqueue(num);
                            num = -1;
                            if (inputQ.Count == 0)
                            {
                                break;
                            }
                        }
                        else
                        {
                            inputQ.Dequeue();
                            resultQ.Enqueue(num * 2);
                            num = -1;
                            if (inputQ.Count == 0)
                            {
                                break;
                            }
                        }
                    }
                }
                int temp = resultQ.Count;
                if (resultQ.Count != MapSize)
                {
                    for(int j = 0; j < MapSize- temp; j++)
                    {
                        resultQ.Enqueue(0);
                    }
                }

                for(int j = 0; j < MapSize; j++)
                {
                    copy_state[j, i] = resultQ.Dequeue();
                }
            } 

            Move(copy_state, count + 1);

            //아래로 이동
            copy_state = (int[,])State.Clone();

            for (int i = 0; i < MapSize; i++)
            {
                // 가지고 있는 블럭 정보를 큐에 저장
                for (int j = MapSize - 1 ; j > -1; j--)
                {
                    inputQ.Enqueue(copy_state[j, i]);
                }

                // 큐의 정보를 바탕으로 위로 이동하는 것을 계산
                int num = -1;
                while (true)
                {
                    if (num == -1)
                    {
                        num = inputQ.Dequeue();
                    }

                    if (inputQ.Count == 0)
                    {
                        resultQ.Enqueue(num);
                        break;
                    }

                    if (num == 0)
                    {
                        num = num + inputQ.Dequeue();
                        if (inputQ.Count == 0)
                        {
                            resultQ.Enqueue(num);
                            break;
                        }
                    }
                    else
                    {
                        if (inputQ.Peek() == 0)
                        {
                            inputQ.Dequeue();
                            if (inputQ.Count == 0)
                            {
                                resultQ.Enqueue(num);
                                break;
                            }
                        }
                        else if (inputQ.Peek() != num)
                        {
                            resultQ.Enqueue(num);
                            num = -1;
                            if (inputQ.Count == 0)
                            {
                                break;
                            }
                        }
                        else
                        {
                            inputQ.Dequeue();
                            resultQ.Enqueue(num * 2);
                            num = -1;
                            if (inputQ.Count == 0)
                            {
                                break;
                            }
                        }
                    }

                    
                }

                if (resultQ.Count != MapSize)
                {
                    int temp = resultQ.Count;
                    for (int j = 0; j < MapSize - temp; j++)
                    {
                        resultQ.Enqueue(0);
                    }
                }

                for (int j = MapSize - 1; j > -1; j--)
                {
                    copy_state[j, i] = resultQ.Dequeue();
                }
            }

            Move(copy_state, count + 1);

            //왼쪽으로 이동
            copy_state = (int[,])State.Clone();

            copy_state = (int[,])State.Clone();
            for (int i = 0; i < MapSize; i++)
            {
                // 가지고 있는 블럭 정보를 큐에 저장
                for (int j = 0; j < MapSize; j++)
                {
                    inputQ.Enqueue(copy_state[i, j]);
                }

                // 큐의 정보를 바탕으로 위로 이동하는 것을 계산
                int num = -1;
                while (true)
                {
                    if (num == -1)
                    {
                        num = inputQ.Dequeue();
                    }

                    if (inputQ.Count == 0)
                    {
                        resultQ.Enqueue(num);
                        break;
                    }

                    if (num == 0)
                    {
                        num = num + inputQ.Dequeue();
                        if (inputQ.Count == 0)
                        {
                            resultQ.Enqueue(num);
                            break;
                        }
                    }
                    else
                    {
                        if (inputQ.Peek() == 0)
                        {
                            inputQ.Dequeue();
                            if (inputQ.Count == 0)
                            {
                                resultQ.Enqueue(num);
                                break;
                            }
                        }
                        else if (inputQ.Peek() != num)
                        {
                            resultQ.Enqueue(num);
                            num = -1;
                            if (inputQ.Count == 0)
                            {
                                break;
                            }
                        }
                        else
                        {
                            inputQ.Dequeue();
                            resultQ.Enqueue(num * 2);
                            num = -1;
                            if (inputQ.Count == 0)
                            {
                                break;
                            }
                        }
                    }
                }

                if (resultQ.Count != MapSize)
                {
                    int temp = resultQ.Count;
                    for (int j = 0; j < MapSize - temp; j++)
                    {
                        resultQ.Enqueue(0);
                    }
                }

                for (int j = 0; j < MapSize; j++)
                {
                    copy_state[i, j] = resultQ.Dequeue();
                }
            }

            Move(copy_state, count + 1);

            //오른쪽으로 이동
            copy_state = (int[,])State.Clone();

            for (int i = 0; i < MapSize; i++)
            {
                // 가지고 있는 블럭 정보를 큐에 저장
                for (int j = MapSize - 1; j > -1; j--)
                {
                    inputQ.Enqueue(copy_state[i, j]);
                }

                // 큐의 정보를 바탕으로 위로 이동하는 것을 계산
                int num = -1;
                while (true)
                {
                    if (num == -1)
                    {
                        num = inputQ.Dequeue();
                    }

                    if (inputQ.Count == 0)
                    {
                        resultQ.Enqueue(num);
                        break;
                    }

                    if (num == 0)
                    {
                        num = num + inputQ.Dequeue();
                        if (inputQ.Count == 0)
                        {
                            resultQ.Enqueue(num);
                            break;
                        }
                    }
                    else
                    {
                        if (inputQ.Peek() == 0)
                        {
                            inputQ.Dequeue();
                            if (inputQ.Count == 0)
                            {
                                resultQ.Enqueue(num);
                                break;
                            }
                        }
                        else if (inputQ.Peek() != num)
                        {
                            resultQ.Enqueue(num);
                            num = -1;
                            if (inputQ.Count == 0)
                            {
                                break;
                            }
                        }
                        else
                        {
                            inputQ.Dequeue();
                            resultQ.Enqueue(num * 2);
                            num = -1;
                            if (inputQ.Count == 0)
                            {
                                break;
                            }
                        }
                    }

                }

                if (resultQ.Count != MapSize)
                {
                    int temp = resultQ.Count;
                    for (int j = 0; j < MapSize - temp; j++)
                    {
                        resultQ.Enqueue(0);
                    }
                }

                for (int j = MapSize - 1; j > -1; j--)
                {
                    copy_state[i, j] = resultQ.Dequeue();
                }
            }

            Move(copy_state, count + 1);

        }

        static void Main(string[] args)
        {
            //Init
            MapSize = int.Parse(Console.ReadLine());

            for (int i = 0; i < MapSize; i++)
            {
                string[] str = Console.ReadLine().Split(' ');
                for(int j = 0; j < MapSize; j++)
                {
                    Map[i, j] = int.Parse(str[j]);
                }
            }

            Move(Map, 0);

            Console.WriteLine(max_value);
        }
    }
}

 

예제 1)

3

2 2 2

4 4 4

8 8 8

답 : 16

 

예제 2)

3

2 2 2

2 2 2

2 2 2

답 : 8

 

예제 3)

5

2 2 4 8 16

0 0 0 0 0

0 0 0 0 0

0 0 0 0 0

2 2 4 8 16

답 : 64

 

예제 4)

7

2 2 2 2 2 2 2

2 0 2 2 2 2 2

2 0 2 2 2 2 2

2 0 2 2 2 2 2

2 2 2 0 2 2 2

2 2 2 2 2 2 0

2 2 2 2 2 2 0

답 : 32

 

채점 결과 창

'코딩테스트 > 백준_문제' 카테고리의 다른 글

2292번. 벌집  (0) 2022.04.02
1712번. 손익분기점  (0) 2022.04.02
1516번. 게임개발(골드3)  (0) 2020.08.13
12849번. 본대산책(실버1)  (0) 2020.08.12
1987번. 알파벳(골드4)  (0) 2020.08.12
COMMENT