경우없는 개발 블로그

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;
}

전체 코드

#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] << ", ";


    }

}

문제 간단 정리

정렬문제 아마도 내장함수를 사용하지 않는다면 n logN의 시간복잡도를 갖는 정렬로 풀어야한다.

문제 해결 방법

sort 내장함수 사용 ><

전체 코드

#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);

    vector<int> vec;
    int n;
    cin >> n;
    
    for (int i = 0; i < n; i++) {
        int input;
        cin >> input;
        vec.push_back(input);
    }
    sort(vec.begin(), vec.end());

    for (int a : vec) {
        cout << a << "\n";
    }
}

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

문제 간단 정리

문제 해결 방법

https://dfdfg42.tistory.com/entry/%EB%B0%B1%EC%A4%80-14246%EB%B2%88-K%EB%B3%B4%EB%8B%A4-%ED%81%B0-%EA%B5%AC%EA%B0%84-C 참고

전체 코드

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

int main()
{
    ll N, M;
    vector<ll> cnt;
    cin >> N >> M;

    for (int i = 0; i < N; i++) {
        ll input;
        cin >> input;
        cnt.push_back(input);

    }
    cnt.push_back(0); //인덱스 때문에 하나 추가



    ll count = 0;
    ll start = 0; ll end=0;
    ll sum = cnt[start];

    while (1) {

        if (sum > M) { //합이 클때

            sum -= cnt[start];

            if (start == end) {
                end++;
                sum += cnt[end];
            }
            start++;

        }
        else if (sum < M) { //합이 적을때

            end++;
            sum += cnt[end];
            
        }
        else if (sum == M) {
            count++;
            sum += cnt[++end];
        }
        if (end == N) break;

    }

    cout << count;
}

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

문제 간단 정리

구간합으로도 될 것 같다. 하지만 투 포인터로 풀어보자 

만약 12345 이고 K가 5일때

현재 123을 합한상태라면 4 5 는 더할 필요 없이 +3만 해주면 된다. 

이를 유의해서 풀

문제 해결 방법

투 포인터를 이용해서 풀어보자..

인덱스를 조심해야된다

전체 코드

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

int main()
{
    ll N, M;
    vector<ll> cnt;
    cin >> N ;

    for (int i = 0; i < N; i++) {
        ll input;
        cin >> input;
        cnt.push_back(input);

    }
    cnt.push_back(0); //인덱스 때문에 하나 추가

    cin >> M;


    ll count = 0;
    ll start = 0; ll end=0;
    ll sum = cnt[start];

    while (1) {

        if (sum > M) { //합이 클때

            sum -= cnt[start];
            count += N - end;

            
            if (start == end) {
                end++;
                sum += cnt[end];
            }
            start++;

        }
        else if (sum <= M) { //합이 적을때

            end++;
            sum += cnt[end];
            
        }
        if (end == N) break;

    }

    cout << count;
}

문제 간단 정리

'' 생략

문제 해결 방법

이 문제는 섬과 섬 사이의 연결 관계를 파악해야 하는 그래프 관련 문제입니다. 이를 효율적으로 파악하기 위해 Union-Find 알고리즘을 사용합니다.

Union-Find는 그래프의 연결 요소를 식별하고 관리하기 위한 알고리즘입니다. Union-Find 알고리즘에서 'union' 연산은 두 집합을 하나로 합치고, 'find' 연산은 특정 원소가 어떤 집합에 속하는지를 찾는 데 사용됩니다.

본 문제에서는 다리 하나가 무너져 서로 왕복할 수 없는 섬들이 생겼습니다. 이때 두 섬을 다시 다리로 이어서 모든 섬이 왕복 가능하도록 해야 합니다. 이를 위해 먼저 주어진 섬 간 연결 정보를 이용해 각 섬의 부모 노드 정보를 업데이트합니다. 이렇게 하면 어떤 섬이 어떤 섬과 연결되어 있는지를 빠르게 알 수 있습니다.

Union-Find 알고리즘을 적용한 코드는 다음과 같습니다.

전체 코드

#include <iostream>
#include <vector>
using namespace std;
int n, m;
int parent[1000001];

int getParent(int x) {
    if (parent[x] == x) return x;
    return parent[x] = getParent(parent[x]);
}

void unionParent(int a, int b) {
    a = getParent(a);
    b = getParent(b);
    if (a > b) parent[a] = b;
    else parent[b] = a;
}

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

    

    int N;
    cin >> N;

    for (int i = 1; i <= N; i++) {
        parent[i] = i;
    }

    for (int i = 1; i <= N - 2; i++) {
        int a, b;
        cin >> a >> b;
        unionParent(a, b);
       
    }
    for (int i2 = 1; i2 <= N - 1; i2++) {
        int A = i2;
        for (int j = i2 + 1; j <= N; j++) {
            int B = j;
            A = getParent(A);
            B = getParent(B);
            if (A != B) {
                cout << A << " " << B;
                return 0;
            }

        }
    }
    

    return 0;

    
}

문제 간단 정리

구현문제이다

각 블럭들을 돌아가면서 조사하면 되는 간단한 구현문제지만

어떻게 구현하냐에 따라서 시간이 달라질것이다.

나는 그냥 모든 블럭들을 조회하는 무식한 방법으로 풀었다.

이렇게 풀면 오류도 많고 틀릴 가능성이 높으니

아마 각 블럭 모양을 만들고 회전시키는 방법이 가장 바람직하지 않을까 싶다

https://stack07142.tistory.com/299 예시

문제 해결 방법

#include<queue>
#include<deque>
#include <iostream>

using namespace std;

int main() {
    int arr[100][100];


    int count = 1;

    while (1) {
        int N; cin >> N;
        if (!N) break;
        //i 세로 j 가로

        int temp = 0;
        int max = -987654321;

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> arr[i][j];
            }
        }

        // ㅡ
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N - 3; j++) {
                temp = 0;
                temp = arr[i][j] + arr[i][j + 1] + arr[i][j + 2] + arr[i][j + 3];
                if (temp > max) max = temp;
            }
        }
        // ㅣ
        for (int i = 0; i < N - 3; i++) {
            for (int j = 0; j < N; j++) {
                temp = 0;
                temp = arr[i][j] + arr[i + 1][j] + arr[i + 2][j] + arr[i + 3][j];
                if (temp > max) max = temp;
            }
        }

        //ㅓ
        for (int i = 0; i < N - 2; i++) {
            for (int j = 0; j < N - 1; j++) {
                temp = 0;
                temp = arr[i + 1][j] + arr[i + 1][j + 1] + arr[i][j + 1] + arr[i + 2][j + 1];
                if (temp > max) max = temp;
            }
        }
        //ㅗ
        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 2; j++) {
                temp = 0;
                temp = arr[i + 1][j] + arr[i + 1][j + 1] + arr[i][j + 1] + arr[i + 1][j + 2];
                if (temp > max) max = temp;
            }
        }
        //ㅜ
        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 2; j++) {
                temp = 0;
                temp = arr[i][j] + arr[i][j + 1] + arr[i][j + 2] + arr[i + 1][j + 1];
                if (temp > max) max = temp;
            }
        }
        //ㅏ
        for (int i = 0; i < N - 2; i++) {
            for (int j = 0; j < N - 1; j++) {
                temp = 0;
                temp = arr[i][j] + arr[i + 1][j] + arr[i + 2][j] + arr[i + 1][j + 1];
                if (temp > max) max = temp;
            }
        }
        //ㅁ
        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 1; j++) {
                temp = 0;
                temp = arr[i][j] + arr[i][j + 1] + arr[i + 1][j] + arr[i + 1][j + 1];
                if (temp > max) max = temp;
            }
        }
        //ㅁㅁ
        //  ㅁㅁ
        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 2; j++) {
                temp = 0;
                temp = arr[i][j] + arr[i][j + 1] + arr[i + 1][j + 1] + arr[i + 1][j + 2];
                if (temp > max) max = temp;
            }
        }

        //  ㅁ
        //ㅁㅁ
        //ㅁ

        for (int i = 0; i < N - 2; i++) {
            for (int j = 0; j < N - 1; j++) {
                temp = 0;
                temp = arr[i][j+1] + arr[i + 1][j+1] + arr[i + 1][j] + arr[i +2][j];
                if (temp > max) max = temp;
            }
        }



        //ㅁㅁㅁ
        //    ㅁ

        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 2; j++) {
                temp = 0;
                temp = arr[i][j] + arr[i][j + 1] + arr[i][j + 2] + arr[i + 1][j + 2];
                if (temp > max) max = temp;
            }
        }
        //  ㅁ
        //  ㅁ
        //ㅁㅁ

        for (int i = 0; i < N - 2; i++) {
            for (int j = 0; j < N - 1; j++) {
                temp = 0;
                temp = arr[i][j + 1] + arr[i + 1][j + 1] + arr[i + 2][j+1] + arr[i + 2][j];
                if (temp > max) max = temp;
            }
        }

        //ㅁ
        //ㅁㅁㅁ

        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 2; j++) {
                temp = 0;
                temp = arr[i][j] + arr[i + 1][j] + arr[i + 1][j + 1] + arr[i + 1][j + 2];
                if (temp > max) max = temp;
            }
        }

        //ㅁㅁ
        //ㅁ
        //ㅁ

        for (int i = 0; i < N - 2; i++) {
            for (int j = 0; j < N - 1; j++) {
                temp = 0;
                temp = arr[i][j + 1] + arr[i][j] + arr[i + 1][j] + arr[i + 2][j];
                if (temp > max) max = temp;
            }
        }

        cout << count << ". " << max << endl;

        count++;
    }
    


    
}

전체 코드

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

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

#문제 간단 정리

이하생략

#문제 해결 방법

끝의 0의 개수는 2*5의 개수로 정해지고,

2는 2의배수만큼 5는 5의 배수만큼 존재하기 때문에 2가 항상 5보다 많다

때문에 5의 개수만 세주면 0의 개수와 같다

이분탐색의 범위는 m*5! 이 무조건 m개의 5의개수보다 많은 5를 가지므로

right를 m*5로 설정해주면 된다.

또한 포함된 5의 개수는 5부터 5의제곱수들을 차례대로 나눈 몫을 구하면 5의 개수를 구하는

함수를 만들 수 있다.

#전체 코드

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;


//5가 들어간 개수를 찾는 함수
int findFive(int a) {
    int count = 0;

    for (int i = 5; i <= a; i *= 5) {
        count += (a / i);
    }
    return count;
}

int main() {

    ios_base::sync_with_stdio(NULL);
    cin.tie(NULL);
    cout.tie(NULL);

    //0의 개수는 5의 개수와 동일
    //제곱이 나오는 경우는 숫자가 건너뛰어짐
    int input;
    cin >> input;

    int left = 1;
    int right = input*5;
    int target = input;
    int result = 0;

    while (left <= right) {
        int mid = (left + right) / 2;

        if (findFive(mid) == target) {
            right = mid -1;
        }
        else if (findFive(mid) > target) {
            right = mid - 1;
        }
        else {
            left = mid + 1;
        }
    }
    
    if (findFive(left) == target) {
        cout << left;
    }
    else {
        cout << -1;
    }
    
    return 0;
}