경우없는 개발 블로그

1018번: 체스판 다시 칠하기 (acmicpc.net)

#문제 간단 정리

문제 상황: 지민이는 MxN 크기의 보드를 발견했습니다. 이 보드는 검은색(B)과 흰색(W)의 정사각형으로 구성되어 있습니다. 지민이는 이 보드에서 8x8 크기의 체스판 부분을 잘라내고 싶습니다.

조건: 체스판의 규칙에 따라 각 칸은 검은색과 흰색으로 번갈아가면서 칠해져야 합니다. 체스판의 맨 왼쪽 위 칸의 색깔에 따라 두 가지 색칠 방식이 있습니다.

목표: 8x8 크기로 잘라낸 부분에서 체스판 규칙에 얼마나 많이 위배되는지 확인하고, 최소 몇 개의 정사각형을 다시 칠해야 하는지 결정하는 프로그램을 작성해야 합니다.    

#문제 해결 방법

목적: 이 코드는 주어진 보드에서 8x8 크기의 체스판을 찾아서, 체스판의 첫 번째 칸이 'W' 또는 'B'로 시작할 때 각각 몇 개의 사각형을 다시 그려야 하는지 계산하고, 그 중 최소값을 출력합니다.

변수 및 자료구조 설명:

• board[50][50]: 전체 보드를 나타내는 2차원 문자 배열입니다.
• N, M: 보드의 크기를 나타내는 변수로, N은 행의 수, M은 열의 수입니다.
• ansPoint: 8x8 체스판을 그릴 때 필요한 최소 수정 횟수를 저장하는 벡터입니다.

함수 설명:

• makeChessBoard(int startX, int startY, int N, int M): 시작점 (startX, startY)에서 8x8 크기의 체스판을 그리기 위해 필요한 최소 수정 횟수를 반환합니다.
  • 체스판의 첫 번째 칸이 'W'로 시작하는 경우와 'B'로 시작하는 경우에 대해 각각 계산하여 더 작은 값을 반환합니다.

메인 프로그램 설명:

1. 입출력 속도 향상을 위한 설정을 합니다.
2. 보드의 크기 N과 M을 입력받습니다.
3. 보드의 각 칸에 대한 값을 입력받아 board에 저장합니다.
4. 모든 위치에서 8x8 크기의 체스판을 그릴 수 있는지 확인하고, 가능한 경우 makeChessBoard 함수를 호출하여 필요한 최소 수정 횟수를 계산하고, ansPoint 벡터에 추가합니다.
5. ansPoint 벡터를 오름차순으로 정렬하고, 첫 번째 원소 (즉, 가장 작은 값)을 출력합니다.

#전체 코드

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

char board[50][50];
int N, M;
vector<int> ansPoint;

int makeChessBoard(int startX, int startY,int N, int M) {
    int ansCount1 = 0;
    int ansCount2 = 0;

    int n = startX + 8;
    int m = startY + 8;

    if (n > N || m > M) {
        return 123456789;
    }

    for (int i = startX; i < n; i++) {
        for (int j = startY; j < m; j++) {
            // 0 0이 W인경우
            if ((i - startX) % 2 == 0 && (j - startY) % 2 == 0) {
                if (board[i][j] == 'B') ansCount1++;
            }
            if ((i - startX) % 2 == 0 && (j - startY) % 2 != 0) {
                if (board[i][j] == 'W') ansCount1++;
            }
            if ((i - startX) % 2 != 0 && (j - startY) % 2 != 0) {
                if (board[i][j] == 'B') ansCount1++;
            }
            if ((i - startX) % 2 != 0 && (j - startY) % 2 == 0) {
                if (board[i][j] == 'W') ansCount1++;
            }

            //0 0이 B 인경우
            if ((i - startX) % 2 == 0 && (j - startY) % 2 == 0) {
                if (board[i][j] == 'W') ansCount2++;
            }
            if ((i - startX) % 2 == 0 && (j - startY) % 2 != 0) {
                if (board[i][j] == 'B') ansCount2++;
            }

            if ((i - startX) % 2 != 0 && (j - startY) % 2 != 0) {
                if (board[i][j] == 'W') ansCount2++;
            }
            if ((i - startX) % 2 != 0 && (j - startY) % 2 == 0) {
                if (board[i][j] == 'B') ansCount2++;
            }
        }
    }

    return(ansCount1 > ansCount2 ? ansCount2 : ansCount1);
}


int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int N, M;
    cin >> N >> M;

    for (int i = 0; i < N; i++) {
        string input; cin >> input;
        for (int j = 0; j < M; j++) {
            board[i][j] = input[j];
        }
    }
    
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            int ans = makeChessBoard(i, j,N,M);
            if (ans != 123456789) {
                ansPoint.push_back(ans);
            }
            
        }
    }
    
    
    sort(ansPoint.begin(), ansPoint.end());
    cout << ansPoint.front();
    

    return 0;
}

#후기

훨씬더 간단한 해결책이 있다...

바로 정답 체스판을 가져와서 비교하는 방법이다.

어쩌면 이렇게 간단한 풀이법이 묘미일지도 모른다 

더 간단한 해결한 블로그 링크

[백준 / BOJ] - 1018번 체스판 다시 칠하기 C++ 풀이 :: Just Give Me The Code (tistory.com)

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

#문제 간단 정리

핵심: 최단거리 문제는 BFS 를 사용하자

DFS를 사용하면 시간 초과가 난다

쉽게 생각해보면 하나의 길을 끝까지 갔다가

다시 되돌아 와서 다시 가니까 

BFS보다 시간이 훨씬 더 걸릴 거라는 것을 알아낼 수 있다.

#문제 해결 방법

1. 전역 변수 선언:
   • maze[100][100]: 미로 정보 저장 (1은 이동 가능, 0은 이동 불가능).
   • check[100][100]: 해당 위치를 방문했는지 여부를 저장.
   • dist[100][100]: 시작점부터 해당 위치까지의 이동 횟수를 저장.
   • dx[], dy[]: 주변 4 방향(상, 하, 좌, 우)을 탐색하기 위한 좌표 변경값.
   • q: BFS(너비 우선 탐색)에 사용되는 큐.
2. findWay 함수:
   • BFS를 사용하여 미로 탐색.
   • 현재 위치에서 상하좌우 4 방향을 탐색하여 이동 가능하고 아직 방문하지 않은 위치를 큐에 추가.
   • 큐에서 뽑힌 위치는 이미 방문한 것이므로 check를 true로 설정.
   • 이동 횟수(dist)는 이전 위치의 이동 횟수 + 1.
3. main 함수:
   • 입력을 받아 미로를 초기화.
   • 시작점인 (0, 0)을 큐에 추가하고 check와 dist를 초기화.
   • findWay 함수를 호출하여 BFS로 미로 탐색.
   • 최종 목적지인 (n-1, m-1)까지의 최단 이동 횟수를 출력.

이 코드의 핵심은 BFS를 사용하여 미로 내에서의 최단 경로를 찾는 것입니다. BFS는 모든 가능한 경로를 너비 우선으로 탐색하므로 최초로 목적지에 도달할 때, 그 경로는 가장 짧은 경로가 보장됩니다.

#전체 코드

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;

int n, m;

int maze[100][100];
int check[100][100] = { false };
int dist[100][100];

int dx[] = { 0, 0, 1, -1 };
int dy[] = { 1,-1,0,0 };
queue<pair <int, int>> q;

void findWay(queue<pair<int,int>> q) {
    while (!q.empty()) {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (0 <= nx && nx < n && 0 <= ny && ny < m) {
                if (check[nx][ny] == false && maze[nx][ny] == 1) {
                    q.push(make_pair(nx, ny));
                    dist[nx][ny] = dist[x][y] + 1;
                    check[nx][ny] = true;
                }
            }
        }
    }
}


int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);


    
    cin >> n >> m;

    for (int i = 0; i < n; i++) {
        string input; cin >> input;
        for (int j = 0; j < m; j++) {
            if (input[j] == '1') {
                maze[i][j] = 1;
            }
            else {
                maze[i][j] = 0;
            }
        }
    }

    q.push(make_pair(0, 0));
    check[0][0] = true;
    dist[0][0] = 1;

    findWay(q);

    

    cout << dist[n-1][m-1];

    return 0;
}

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

#전체 코드

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

string input1;
string input2;

void findAns(int i, int j, vector<vector<int>>& dp) {
    if (i == 0 || j == 0) return; // Base case
    if (input1[i - 1] == input2[j - 1]) {
        findAns(i - 1, j - 1, dp);
        cout << input1[i - 1];
    }
    else {
        if (dp[i - 1][j] > dp[i][j - 1]) {
            findAns(i - 1, j, dp);
        }
        else {
            findAns(i, j - 1, dp);
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> input1 >> input2;

    int n = input1.size();
    int m = input2.size();

    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (input1[i - 1] == input2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
            }
            else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }

    cout << dp[n][m] << endl;

    findAns(n, m, dp); // 출력 함수 호출

    return 0;
}

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

#전체 코드

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <cstring>

using namespace std;
vector<int> a[1001];
bool check[1001];

void dfs(int node) {
    check[node] = true;
    cout << node<<" ";

    for (int i = 0; i < a[node].size(); i++) {
        int next = a[node][i];
        if (check[next] == false) {
            dfs(next);
        }
    }
}

void bfs(int start) {
    queue<int> q;
    memset(check, false, sizeof(check));
    check[start] = true;
    q.push(start);

    while (!q.empty()) {
        int node = q.front();
        q.pop();
        cout << node<<" ";
        for (int i = 0; i < a[node].size(); i++) {
            int next = a[node][i];
            if (check[next] == false) {
                check[next] = true;
                q.push(next);
            }
        }
    }
}

int main() {
    int n, m, start;

    cin >> n >> m >> start;

    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        a[u].push_back(v);
        a[v].push_back(u);
    }
    for (int i = 1; i <= n; i++) {
        sort(a[i].begin(), a[i].end());
    }

    dfs(start);
    puts("");

    bfs(start);
    puts("");

    

    return 0;
}

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

#전체 코드

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
public class Program
{
    public static void Main()
    {
        int input = int.Parse(Console.ReadLine());

        int nd=0,nm=0,nDemo=1,nMole=0,ndCount=0,nmCount=0;
        

        //input이 1일때의 예외상황을 추가해주자
        if(input == 1)
        {
            Console.WriteLine("1/1");
        }
        else
        {
            while (ndCount < input)
            {


                if (nd == 0) //첫번쨰항인 1을 추가해주자
                {
                    ndCount++;
                    //Console.WriteLine("{0}!! nd", nd+1);
                }
                if (nd == 1)//끝나고 시작할때 부족한 1을 추가해주자
                {
                    ndCount++;
                    //Console.WriteLine("{0}!! nd", nd);
                }


                nDemo += 2;


                while (nd < nDemo)
                {
                    if (ndCount == input)
                    {
                        break;
                    }
                    nd++;
                    ndCount++;

                    //Console.WriteLine("{0}// nd {1} //ndCount", nd,ndCount);
                }
                while (nd > 1)
                {
                    if (ndCount == input)
                    {
                        break;
                    }
                    nd--;
                    ndCount++;
                    //Console.WriteLine("{0}// nd {1} //ndCount", nd, ndCount);
                }



            }

            while (nmCount < input)
            {

                if (nm == 1) //첫번째항 보충할 필요없이 끝날때의 1만 추가해주자
                {
                    nmCount++;
                    //Console.WriteLine("{0}!! nm", nm);
                }

                nMole += 2;

                while (nm < nMole)
                {
                    if (nmCount == input)
                    {
                        break;
                    }
                    nm++;
                    nmCount++;
                    //Console.WriteLine("{0}]] nm", nm);
                }
                while (nm > 1)
                {
                    if (nmCount == input)
                    {
                        break;
                    }
                    nm--;
                    nmCount++;
                    //Console.WriteLine("{0}]] nm", nm);
                }

            }



            if (ndCount >= input && nmCount >= input)
            {
                Console.WriteLine("{0}/{1}", nd, nm);
                //Console.ReadKey();
            }
        }
        //Console.ReadKey();

        


    }
}

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

#간단해설

띄어쓰기를 구분하면 되는 간단한 문제

노하우가 좀 필요할지도

#전체 코드

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {



        static public void Main(string[] args)
        {
            string getStringA = Console.ReadLine();
            char[] delimiterChars = { ' ' };
            int count = 0;

            string[] arrayA = getStringA.Split(delimiterChars, StringSplitOptions.RemoveEmptyEntries);

            

            Console.WriteLine(arrayA.Length);
            Console.ReadKey();
        }

        
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {



        static public void Main(string[] args)
        {
            string getStringA = Console.ReadLine();

            int count = 0;

            string[] arrayA = getStringA.Split(' ');

            for(int i=0; i<arrayA.Length; i++)
            {
                if (arrayA[i] == "")
                {
                    count++;
                }
            }

            Console.WriteLine(arrayA.Length-count);
            Console.ReadKey();
        }

        
    }
}

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

#전체 코드

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            
            //새로운 수 만들기 -> 새로운 수 비교 

            string input = Console.ReadLine();

            int repeat = 1;
            int[] array = new int[100]; //비교할 값들을 저장
            int count = 1; 
            array[0] = int.Parse(input);//첫번쨰 배열에는 처음 입력값 저장
            string inputFirstNumber, inputSecondNumber;
            int newNumber,final;

            while (repeat ==1)
            {
                if (int.Parse(input) < 10)
                {
                    
                    inputSecondNumber = input.Substring(0, 1);

                    final = int.Parse(inputSecondNumber) * 10 + int.Parse(inputSecondNumber);
                    array[count] = final;

                }
                else
                {
                    inputFirstNumber = input.Substring(0, 1);
                    inputSecondNumber = input.Substring(1, 1);
                    newNumber = int.Parse(inputFirstNumber) + int.Parse(inputSecondNumber);

                    string stringNewNumber = newNumber.ToString();
                    string newSecondNumber;

                    if (newNumber < 10)
                    {
                        newSecondNumber = stringNewNumber.Substring(0, 1);
                    }
                    else
                    {
                        newSecondNumber = stringNewNumber.Substring(1, 1);
                    }
                    

                    final = (int.Parse(inputSecondNumber) * 10) + int.Parse(newSecondNumber);
                    array[count] = final;


                }




                //새로운 수 비교

                for (int i = 0; i < count; i++)
                {
                    if (array[i] == array[count])
                    {
                        Console.WriteLine("{0}", count);
                        repeat = 0;

                    }
                }

                count++;

                input = final.ToString();
                
            }

            
               
            

        }
    }
}

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

전체 코드

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {



        static public void Main(string[] args)
        {
            string getA = (Console.ReadLine());

            //각리수의 숫자를 뽑아내서 배열에 저장 -> 차이를 비교해서 저장
            //99까지는 어차피 한수니까 예외처리하자

            Console.WriteLine(Aberration(getA));
            Console.ReadKey();


        }

        static int Aberration(string d)
        {


            int count = 99;
            int[] arrayA = new int[1001];

            //예외처리
            if (d.Length > 2 && d.Length < 5)
            {
                //100부터 입력숫자까지 한수계산
                for (int e = 100; e <= int.Parse(d); e++)
                {

                    string insA = e.ToString();

                    for (int i = 0; i < insA.Length; i++)
                    {
                        arrayA[i] = int.Parse(insA[i].ToString());
                    }

                    //3자리수 아니면 1000 이다. 3자리수일때만 처리하면 더 편할거다.
                    if(insA.Length != 4)
                    {
                        //커지는 등차수열 작아지는 등차수열 구분
                        if (arrayA[0] >= arrayA[1] && arrayA[1] >= arrayA[2])
                        {

                            if ((arrayA[0] - arrayA[1]) == (arrayA[1] - arrayA[2]))
                            {
                                count++;
                            }

                        }

                        if (arrayA[0] < arrayA[1] && arrayA[1] < arrayA[2])
                        {


                            if ((arrayA[1] - arrayA[0]) == (arrayA[2] - arrayA[1]))
                            {
                                count++;
                            }

                        }
                    }


                    
                }
                return count;

            }
            

            return int.Parse(d);

           
        }
    }
}

전체 코드

#include<vector>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int arr[10001] = { 0, };
    int n;
    cin >> n;

    for (int i = 1; i <= n; i++) {
        int input;
        cin >> input;
        arr[input]++;
        
    }

    for (int i = 1; i <= 10000; i++) {
        if (arr[i] != 0) {
            for (int j = 1; j <= arr[i]; j++) {
                cout << i << "\n";
            }
        }
    }
}

다른 정렬방법으로 나중에 풀어봐야겠다.

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

문제 간단 정리

원으로 앉아있고 K번째마다 제거되기 때문에 K 번째가 아닐때는 제외하고 큐를 사용하여 뒤를 넘겨주면 

구현이 가능할테지만... 큐를 사용하지 않고 풀었다, 큐를 사용해서 푼 블로그 참조 https://cocoon1787.tistory.com/234

하지만 나는 그냥 큐 사용을 안하고 구현될 것 같아서 다르게 풀었다.

문제 해결 방법

대략 내가 직접 하나하나 세가면서 한다 생각하고 구현하였다.

수를 제거함을 알기위해서 count 변수, 지금 가리키고 있는 수인 포인터 index 변수

수가 제거되었는지 체크하기 위해서 bool 변수 flag를 설정해 두었다.

flag가 false라면 count++(그 수를 지나감을 의미) ,

count가 K(번째 수)가 되었다면 그 수를 제외하고(flag를 true로) 정답에 넣기

정답의 수가 총 N의 개수와 같아진다면 break;

만일 index가 범위를 벗어났다면 1로 초기화

전체 코드

#include<vector>
#include <iostream>
using namespace std;


int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int N, K;
    cin >> N >> K;

    int index = 1, count = 0;
    bool flag[1001] = { 0, };
    vector<int> ans;

    while (1) {


        if (flag[index] == false) {
            
            count++;

            if (count == K) {
                ans.push_back(index);
                flag[index] = true;
                count = 0;
            }
        }

        if (ans.size() == N) {
            break;
        }

        index++;
        if (index > N) {
            index = 1;
        }

        //cout << "index:" << index << "\n";
    }

    cout << "<";
    for (int i = 0; i < ans.size(); i++) {
        if (i == ans.size() - 1) {
            cout << ans[i] << ">";

        }else cout << ans[i] << ", ";


    }

}