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

 

7562번: 나이트의 이동

체스판 위에 한 나이트가 놓여져 있다. 나이트가 한 번에 이동할 수 있는 칸은 아래 그림에 나와있다. 나이트가 이동하려고 하는 칸이 주어진다. 나이트는 몇 번 움직이면 이 칸으로 이동할 수

www.acmicpc.net

#문제 간단 정리

 

체스판 위에서 나이트가 이동하는 최소 횟수를 계산하는 문제를 해결하기 위한 코드입니다. 코드는 입력으로 주어지는 테스트 케이스를 처리하고, 각 테스트 케이스에 대해 나이트가 최소 몇 번 움직여야 하는지를 출력합니다. 코드는 너비 우선 탐색(BFS)을 사용하여 문제를 해결합니다

 

#전체 코드

#include <iostream>
#include <queue>

using namespace std;

int dx[] = { 2, 1, -1, -2, -2 ,-1,1,2, };
int dy[] = { 1,2,2,1,-1,-2,-2,-1 };

struct point {
	int x, y;
};

int main() {


	int N; cin >> N;
	while (N--) {
		int I;
		cin >> I;
		point now, target;
		cin >> now.x >> now.y >> target.x >> target.y;

		if (now.x == target.x && now.y == target.y) {
			cout << '0' << endl;
			continue;
		}

		int chessBoard[300][300] = { 0, };

		queue<point> q;
		q.push(now);
		chessBoard[q.front().x][q.front().y] = 0;

		while (!q.empty()) {
			int x = q.front().x;
			int y = q.front().y;
			q.pop();
			for (int i = 0; i < 8; i++) {
				int nx = x + dx[i];
				int ny = y + dy[i];
				if (0 <= nx && nx < I && 0 <= ny && ny < I) {
					if (chessBoard[nx][ny] == 0) {
						q.push({ nx,ny });
						chessBoard[nx][ny] = chessBoard[x][y] + 1;
					}
				}

			}
		}

		cout << chessBoard[target.x][target.y]<< endl;

		
	}






	return 0;
}

 

 

#문제 해결 방법

해당 문제는 나이트의 이동을 최소한의 움직임으로 목표 위치까지 가는 최단 거리를 찾는 문제입니다. 이를 위해 BFS(Breadth-First Search)를 사용합니다.

문제 해설:

  1. 나이트의 이동
    나이트는 8가지 방향으로 움직일 수 있습니다. 문제에서 제시한 그림을 참고하면, 나이트의 모든 움직임을 (dx, dy)의 형태로 나타낼 수 있습니다.
  2. BFS
    BFS는 시작 지점부터 가장 가까운 지점들부터 차례대로 탐색하는 알고리즘입니다. 체스판에서의 나이트 이동도 이 알고리즘으로 효율적으로 해결할 수 있습니다. BFS를 사용하면, 각 칸에 도달하는 데 필요한 최소한의 움직임 횟수를 찾을 수 있습니다.

코드 설명:

  • 변수
    • dx, dy: 나이트의 이동 방향을 저장한 배열입니다.
    • point: x, y 좌표를 갖는 구조체입니다.
    • chessBoard: 각 위치에 도달하기 위한 최소 움직임 횟수를 저장하는 체스판입니다.
  • 프로세스
    1. 테스트 케이스의 수를 입력 받습니다.
    2. 각 테스트 케이스마다
      • 체스판의 크기, 시작 위치, 목표 위치를 입력 받습니다.
      • 시작 위치와 목표 위치가 같다면, 움직일 필요가 없으므로 0을 출력하고 다음 테스트 케이스로 넘어갑니다.
      • 그렇지 않다면, BFS로 최단 거리를 찾습니다.
      • BFS를 진행하며, 체스판에 각 칸까지 도달하기 위한 최소 움직임 횟수를 저장합니다.
      • 목표 위치까지의 최소 움직임 횟수를 출력합니다.

BFS를 사용하여 문제를 해결하면, 체스판의 각 칸까지 도달하는 데 필요한 최소 움직임 횟수를 효율적으로 찾을 수 있습니다.

 

'[백준] > C++' 카테고리의 다른 글

백준 13019번 A를 B로 [C++]  (0) 2023.09.17
백준 7576번 토마토 [C++]  (0) 2023.09.14
백준 1018번 체스판 다시 칠하기 [C++]  (0) 2023.09.06
백준 2178번 미로 탐색[C++]  (0) 2023.09.06
백준 9252번 LCS 2 [C++]  (0) 2023.09.03

 

 

 

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

 

1018번: 체스판 다시 칠하기

첫째 줄에 N과 M이 주어진다. N과 M은 8보다 크거나 같고, 50보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에는 보드의 각 행의 상태가 주어진다. B는 검은색이며, W는 흰색이다.

www.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)

 

[백준 / BOJ] - 1018번 체스판 다시 칠하기 C++ 풀이

백준 - 단계별로 풀어보기 [1018] 체스판 다시 칠하기 https://www.acmicpc.net/problem/1018 문제 M*N 크기의 보드를 잘라 8x8크기의 체스판을 얻으려고 하는데, 주어진 보드에서 8x8 체스판을 만들때, 가장 적

cryptosalamander.tistory.com

 

'[백준] > C++' 카테고리의 다른 글

백준 7576번 토마토 [C++]  (0) 2023.09.14
백준 7562번 나이트의 이동 [C++]  (0) 2023.09.14
백준 2178번 미로 탐색[C++]  (0) 2023.09.06
백준 9252번 LCS 2 [C++]  (0) 2023.09.03
백준 1260번 DFS와BFS [C++]  (0) 2023.08.30

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

 

2178번: 미로 탐색

첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

www.acmicpc.net

 

#문제 간단 정리

핵심: 최단거리 문제는 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

 

9252번: LCS 2

LCS(Longest Common Subsequence, 최장 공통 부분 수열)문제는 두 수열이 주어졌을 때, 모두의 부분 수열이 되는 수열 중 가장 긴 것을 찾는 문제이다. 예를 들어, ACAYKP와 CAPCAK의 LCS는 ACAK가 된다.

www.acmicpc.net

 

 

#전체 코드

#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

 

1260번: DFS와 BFS

첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는 두 정점의 번호가 주어진다. 어떤 두 정점 사

www.acmicpc.net

 

#전체 코드

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

'[백준] > C++' 카테고리의 다른 글

백준 2178번 미로 탐색[C++]  (0) 2023.09.06
백준 9252번 LCS 2 [C++]  (0) 2023.09.03
백준 10989번 수 정렬하기 3 [C++]  (0) 2023.08.05
백준 11866번 요세푸스 문제 0 [C++]  (0) 2023.08.04
백준 2751번 수 정렬하기 2 [C++]  (0) 2023.08.04

https://school.programmers.co.kr/learn/courses/30/lessons/42888?language=cpp 

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

대략 요약

요약

#전체 코드

#include <string>
#include <vector>
#include <sstream>
#include <map>
#include <iostream>

using namespace std;

vector<string> solution(vector<string> record) {
    vector<string> answer;
    
    map<string,string> m;
    vector<vector<string>> seq;
    
    //seq 실행 목록 저장


        for(auto r: record){
            stringstream ss;
            ss.str(r);
            string enter,id,name;
            ss >> enter >> id >> name;
            
            vector<string> sol;
            sol.push_back(enter);
            sol.push_back(id);
            sol.push_back(name);
            seq.push_back(sol);
            
            if(enter == "Enter" || enter == "Change"){
                m[id] = name;
            }

            sol.clear();
        }
    //출력
    for(int i=0; i<seq.size(); i++){
        if(seq[i][0] == "Enter"){
            answer.push_back(m[seq[i][1]] + "님이 들어왔습니다.");

        }
        else if(seq[i][0] == "Leave"){
            answer.push_back(m[seq[i][1]] + "님이 나갔습니다.");

        }
    }

    
    return answer;
}

#도움을 받은 곳

https://se-jung-h.tistory.com/entry/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98C-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-level-2-%EC%98%A4%ED%94%88%EC%B1%84%ED%8C%85%EB%B0%A9

 

알고리즘(C++) / 프로그래머스 level 2 : 오픈채팅방

level 2 : 오픈채팅방 https://programmers.co.kr/learn/courses/30/lessons/42888?language=cpp 코딩테스트 연습 - 오픈채팅방 오픈채팅방 카카오톡 오픈채팅방에서는 친구가 아닌 사람들과 대화를 할 수 있는데, 본래

se-jung-h.tistory.com

 

#고찰

map 을 사용해서 id 와 이름을 매치시켜주고

입력에 따라서 한차례 차례대로 정리하고

정답에 id와 매치한값으로 정리해서 넣어주면 된다..

map STL 사용과 sstream 을 문자열 처리를 위해 사용하면 편하게 풀 수 있다.

 

https://school.programmers.co.kr/learn/courses/30/lessons/60059

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

#문제 간단 정리

 

2차원 배열을 이용하여 자물쇠와 키를 대조하여 정답을 찾자.

다만 키가 자물쇠의 영역을 벗어나는 것이 주목 포인트다

 

 

 

#문제 해결 방법

일단 대략적인 내용은 문제를 읽어서 이해했다고 치고

큰 문제 해결의 맥락을 잡으면

1. 키와 자물쇠를 2차원 배열을 이용해서 표시한다.

2. 그렇게 받은 키의 회전 함수를 구현한다. (하나씩 대조하면서 좌표가 어떻게 변하는지 확인하자)

3. 키를 자물쇠에 넣어서 확인한다.

 

이 문제에서는 3번이 핵심이 된다.

우선 처음에는 방법 두어가지가 떠오르는데.

3-1. 자물쇠에 넣을 키의좌표를 유동적으로 넣어가면서 검사.

3-2.  자물쇠를 연장시켜서 자물쇠*3의 맵을 만들어 키를 넣어가면서 검사.

 

우선 1번이 좀 더 고급진 방법이겠지만

구현문제이기 때문에 가장 구현이 쉽고 간단할 3-2번 방법으로 선택

그림으로 표현하자면  대략 다음과 같다

자물쇠를 *3 하여 연장

그림을 보면  나는  n(자물쇠)*3 로 구현을 했지만 키가 완전히 맵과 안겹치는건 쓸모가 없기 때문에 한칸 줄여서 맵을 만들면 좀 더 속도가 빨라졌을 것이다.

 

이후 내가 푸는 방법은

자물쇠의 0의 개수를 세준다음

연장한 자물쇠는 모두 2로 채워준다

그리고 키를 첫번째 칸부터 마지막 칸까지 이동시키면서 대조한후

회전시킨후 반복을 3번 더 시켜준다 (360도)

그림으로 보이자면 대략 이렇다

키를 대입한 연장 자물쇠

만약 대조하면서 키가 1 자물쇠가 0 라면 정답 카운트 +1

자물쇠가 1 키가 1 이면 정답 카운트를 -123456789로 설정하여 오답처리

자물쇠가 0 키가 0 이여도 오답처리

 

정답카운트가 자물쇠의 빈 공간 카운트와 일치한다면

정답을 찾은것이다.

 

사실 여기서 자물쇠의 키의값을 더해서 정답을 찾아도 좋을 것 같고.

우선 주어진 맵의 길이가 20정도로 작기 때문에 연장후 회전까지 한 테스트 케이스가

생각보다 작기 때문에 단순한 맵 연장이 가장 좋을 것 같다는 생각이 들었다.

(단순하고 틀리기 가장 어려우니까)

 

 

 

#전체 코드

 

#include <string>
#include <vector>
#include <iostream>
int n,m;


using namespace std;

vector<vector<int>> rotate(vector<vector<int>> key){ // key 시계방향 90도 회전
    vector<vector<int>> tmp;
    tmp.resize(n,vector<int>(n,0));
    
    for(int i=0;i<m;i++){
        for(int j=0;j<m;j++){
            tmp[i][j] = key[m-1-j][i];
        }
    }
    return tmp;
}



int match(){
    
}

bool solution(vector<vector<int>> key, vector<vector<int>> lock) {
    
    bool answer = false;
    m = key[0].size(); n = lock[0].size();

    vector<vector<int>> newMap;
    newMap.resize(n*3,vector<int>(n*3,2)); // 확장된 자물쇠 m*3의 크기
    
    
    int countEmpty = 0;
    cout << "map: \n";
    for(int i=0;i<n;i++){ //lock 의 빈 공간 카운트
        for(int j=0;j<n;j++){
            if(lock[i][j] == 0){
                countEmpty++;
            } 
            newMap[i+m][j+m] = lock[i][j]; //newMap 갱신
            cout << lock[i][j] <<" "; //map 출력
        }
        cout << "\n";
    }
    
    cout << "key: \n";
    for(int i=0;i<m;i++){
        for(int j=0;j<m;j++){
            cout << key[i][j] << " ";
        }
        cout << "\n";
    }
    
    cout << "emptyCount: " << countEmpty << "\n";

    for(int k=0; k<4; k++){
        if(k != 0) key = rotate(key);

    
    for(int i=0;i<m*3;i++){ //match 인지 확인하기
        for(int j=0;j<m*3;j++){
            
            //lock에 맞는지 확인하는 구간
            int ansCount = 0;
            for(int i2=0; i2<m; i2++){
                for(int j2=0; j2<m; j2++){
                    if(i2 + i < n*3 && j2 + j <n*3){ //범위 제한
                        
                    
                    if(newMap[i+i2][j+j2] == 0 && key[i2][j2] == 1 ){ 
                            ansCount++;
                    }  
                    if(newMap[i+i2][j+j2] == 0 && key[i2][j2] == 0){ 
                            ansCount = -123456789;
                    } 
                    if(newMap[i+i2][j+j2] == 1 && key[i2][j2] == 1){ 
                            ansCount = -123456789;
                    } 
                        
                    }//범위지정
                }   
            }
            cout << ansCount << " ";
             if(ansCount == countEmpty){
                        answer = true;
                }
        }
        
    } 
        
    } // 회전
    
    
    
    return answer;

}

 

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

 

1193번: 분수찾기

첫째 줄에 X(1 ≤ X ≤ 10,000,000)가 주어진다.

www.acmicpc.net

#전체 코드

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

        


    }
}

'[백준] > C#' 카테고리의 다른 글

백준 1152번 단어의 개수 [C#]  (0) 2023.08.05
백준 1110번 더하기 사이클 [C#]  (0) 2023.08.05
백준 1065번 한수 [C#]  (2) 2023.08.05

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

 

1152번: 단어의 개수

첫 줄에 영어 대소문자와 공백으로 이루어진 문자열이 주어진다. 이 문자열의 길이는 1,000,000을 넘지 않는다. 단어는 공백 한 개로 구분되며, 공백이 연속해서 나오는 경우는 없다. 또한 문자열

www.acmicpc.net

 

#간단해설

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

노하우가 좀 필요할지도

#전체 코드

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

        
    }
}

'[백준] > C#' 카테고리의 다른 글

백준 1193번 분수찾기 [C#]  (0) 2023.08.05
백준 1110번 더하기 사이클 [C#]  (0) 2023.08.05
백준 1065번 한수 [C#]  (2) 2023.08.05

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

 

1110번: 더하기 사이클

0보다 크거나 같고, 99보다 작거나 같은 정수가 주어질 때 다음과 같은 연산을 할 수 있다. 먼저 주어진 수가 10보다 작다면 앞에 0을 붙여 두 자리 수로 만들고, 각 자리의 숫자를 더한다. 그 다음,

www.acmicpc.net

 

#전체 코드

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

            
               
            

        }
    }
}

'[백준] > C#' 카테고리의 다른 글

백준 1193번 분수찾기 [C#]  (0) 2023.08.05
백준 1152번 단어의 개수 [C#]  (0) 2023.08.05
백준 1065번 한수 [C#]  (2) 2023.08.05

+ Recent posts