Study hard

프로그래머스 코딩테스트 연습 - 2주차_상호평가

Nimgnoej — Fri, 8 Oct 2021 15:24:52 +0900

https://programmers.co.kr/learn/courses/30/lessons/83201#

코딩테스트 연습 - 2주차_상호평가

[[100,90,98,88,65],[50,45,99,85,77],[47,88,95,80,67],[61,57,100,80,65],[24,90,94,75,65]] "FBABD" [[70,49,90],[68,50,38],[73,31,100]] "CFD"

programmers.co.kr

[풀이]

i번 학생이 자신에게 준 점수가 자신이 받은 점수 중 유일한 최저점이거나 유일한 최고점이면 평균을 구하는 식에서 제외한다.

#include <string>
#include <vector>
#include <algorithm>//sort

using namespace std;

string solution(vector<vector<int>> scores) {
    string answer = "";
    int N=scores[0].size();
    for(int i=0;i<N;i++){
        //i번 학생이 자신에게 준 점수
        int mine=scores[i][i];
        vector<int>tmp;
        double score=0;
        int cnt=0;
        for(int j=0;j<N;j++){
            tmp.push_back(scores[j][i]);
            score+=scores[j][i];
            cnt++;
        }
        sort(tmp.begin(),tmp.end());
        //유일한 최소인지
        if(tmp.front()==mine&&mine!=tmp[1]){
            score-=mine;
            cnt--;
        }
        //유일한 최대인지
        else if(tmp.back()==mine&&mine!=tmp[N-2]){
            score-=mine;
            cnt--;
        }
        score/=cnt;
        if(score>=90)
            answer+='A';
        else if(score>=80&&score<90)
            answer+='B';
        else if(score>=70&&score<80)
            answer+='C';
        else if(score>=50&&score<70)
            answer+='D';
        else
            answer+='F';
    }
    return answer;
}

(c++)백준 21610번: 마법사 상어와 비바라기

Nimgnoej — Wed, 8 Sep 2021 15:08:06 +0900

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

21610번: 마법사 상어와 비바라기

마법사 상어는 파이어볼, 토네이도, 파이어스톰, 물복사버그 마법을 할 수 있다. 오늘 새로 배운 마법은 비바라기이다. 비바라기를 시전하면 하늘에 비구름을 만들 수 있다. 오늘은 비바라기

www.acmicpc.net

[풀이]

구현한 것(함수)

1. 구름 이동 함수 (d와 s를 받는 즉시 호출) s는 s%N으로 최소화하여 움직이는 시간 줄이기

2. 각 구름에서 비가 내려 구름이 있는 칸의 바구니에 물+1 함수

*문제에서는 이 다음에 구름이 사라지지만, 구현할 때는 다음 함수에서 사용하기 위해 구름 위치 정보를 남겨둠

3. 물복사버그 함수 -> 구름 위치 정보 삭제(p_Cloud)

4. bool Cloud[][]배열에 이전에 구름이 있었던 위치 저장해놓았으므로, c_Cloud[][]에 복사하고, 이전에 구름이 없었고, 물의 양이 2 이상인 모든 칸에 구름 새로 생김 -> 구름 위치정보(p_Cloud), Cloud[][]에 표시

[코드]

#include <iostream>
#include <deque>
#include <cstring>//memset
using namespace std;

struct Pos {
	int x, y;
};

int N, M;
int A[51][51];
bool Cloud[51][51];
bool c_Cloud[51][51];
deque<Pos>p_Cloud;//구름 위치
const int dxy[][2] = { {0,0},{0,-1},{-1,-1},{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1} };

//d방향으로 s칸만큼 구름 이동
void MoveCloud(int d, int s) {
	memset(Cloud, false, sizeof(Cloud));
	int cloud_cnt = p_Cloud.size();
	for (int i = 0; i < cloud_cnt; i++) {
		int x = p_Cloud.front().x;
		int y = p_Cloud.front().y;
		p_Cloud.pop_front();
		//실제 이동하는 칸
		int rs = s % N;
		while (rs--) {
			x += dxy[d][0];
			y += dxy[d][1];
			if (x > N)
				x = 1;
			else if (x <= 0)
				x = N;
			if (y > N)
				y = 1;
			else if (y <= 0)
				y = N;
		}
		p_Cloud.push_back({ x,y });
		Cloud[x][y] = true;
	}
}

//각 구름에서 비가 내려 구름이 있는 칸 바구니에 물+1
void Rain() {
	int cloud_cnt = p_Cloud.size();
	for (int i = 0; i < cloud_cnt; i++) {
		int x = p_Cloud[i].x;
		int y = p_Cloud[i].y;
		A[x][y]++;
	}
}

//물복사 버그 : 대각선 방향으로 거리가 1인 칸에 물이 있는 바구니의 수만큼 (r,c)에 있는 바구니의 물의 양이 증가
void Copy() {
	int cloud_cnt = p_Cloud.size();
	for (int i = 0; i < cloud_cnt; i++) {
		int x = p_Cloud[i].x;
		int y = p_Cloud[i].y;
		int water_cnt = 0;
		for (int d = 2; d <= 8; d += 2) {
			int nx = x + dxy[d][0];
			int ny = y + dxy[d][1];
			//범위 벗어나면 continue
			if (nx <= 0 || nx > N || ny <= 0 || ny > N)
				continue;
			if (A[nx][ny] > 0)
				water_cnt++;
		}
		A[x][y] += water_cnt;
	}
	//구름 사라지기
	p_Cloud.clear();
}

//방금 구름 사라진 칸 제외 물의 양이 2 이상인 모든 칸에 구름이 생김
void makeCloud() {
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			c_Cloud[i][j] = Cloud[i][j];
			Cloud[i][j] = false;
		}
	}
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			if (A[i][j] >= 2 && c_Cloud[i][j] == false) {
				p_Cloud.push_back({ i,j });
				Cloud[i][j] = true;
				A[i][j] -= 2;
			}
		}
	}
}

int main() {
	cin >> N >> M;
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			cin >> A[i][j];
		}
	}
	//초기 구름
	p_Cloud.push_back({ N,1 });
	p_Cloud.push_back({ N,2 });
	p_Cloud.push_back({ N - 1,1 });
	p_Cloud.push_back({ N - 1,2 });

	int d, s;

	for (int i = 0; i < M; i++) {
		cin >> d >> s;
		MoveCloud(d, s);
		Rain();
		Copy();
		makeCloud();
		/*
		cout << '\n';
		for (int x = 1; x <= N; x++) {
			for (int y = 1; y <= N; y++) {
				cout << A[x][y] << ' ';
			}
			cout << '\n';
		}
		cout << '\n';
		*/
	}
	int answer = 0;
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			answer += A[i][j];
		}
	}
	cout << answer << '\n';
	return 0;
}

(c++)백준 21609번: 상어 중학교

Nimgnoej — Wed, 8 Sep 2021 13:33:02 +0900

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

21609번: 상어 중학교

상어 중학교의 코딩 동아리에서 게임을 만들었다. 이 게임은 크기가 N×N인 격자에서 진행되고, 초기에 격자의 모든 칸에는 블록이 하나씩 들어있고, 블록은 검은색 블록, 무지개 블록, 일반 블록

www.acmicpc.net

[풀이]

구현한 것(함수)

1. 블록그룹 정보 저장 함수(bfs)-> vector에 저장하여 sort 활용하여 가장 큰 그룹 찾기

2. 가장 큰 블록 삭제하는 함수(bfs)

3. 블록들을 밑으로 내리는 함수

4. 시계 반대 방향으로 90도 돌리는 함수(바깥 -> 안 순서로 돌리기)

#include <iostream>
#include <algorithm>//sort
#include <cstring>//memset
#include <vector>
#include <cmath>//pow
#include <queue>
using namespace std;

struct Pos {
	int x, y;
};

struct Group {
	int x, y;//기준블록 좌표
	int s;//그룹 크기
	int rainbow;//무지개 블록 수
};

bool sortGroup(const Group &A, const Group &B) {
	//크기가 같으면
	if (A.s == B.s) {
		//무지개 블록 수가 같으면
		if (A.rainbow == B.rainbow) {
			//기준 블록 행 같으면
			if (A.x == B.x) {
				//기준 블록 열이 가장 큰 것
				return A.y > B.y;
			}
			else {
				return A.x > B.x;
			}
		}
		else {
			return A.rainbow > B.rainbow;
		}
	}
	return A.s > B.s;
	
}

int N, M;
bool visited[20][20] = {false,};
bool rvisited[20][20] = { false, };
int Map[20][20];
int Score = 0;
vector<Group>group;
const int dx[] = { -1,1,0,0 };
const int dy[] = { 0,0,-1,1 };

//각 그룹의 크기, 무지개 블록 수 구하기
void getInfo(int startx, int starty) {
	queue<Pos>q;
	visited[startx][starty] = true;
	q.push({ startx,starty });
	int color = Map[startx][starty];
	int groupSize = 1;
	int rainbowCnt = 0;
	while (!q.empty()) {
		int x = q.front().x;
		int y = q.front().y;
		q.pop();
		for (int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if (nx<0 || nx>=N || ny<0 || ny>=N)
				continue;
			//다음 블록이 무지개블록이면
			if (Map[nx][ny] == 0 && rvisited[nx][ny] == false) {
				rvisited[nx][ny] = true;
				rainbowCnt++;
				groupSize++;
				q.push({ nx,ny });
			}
			//다음 블록이 같은 블록이면
			else if (color == Map[nx][ny] && visited[nx][ny] == false) {
				visited[nx][ny] = true;
				groupSize++;
				q.push({ nx,ny });
			}
		}
	}
	if(groupSize >= 2)
		group.push_back({ startx,starty,groupSize,rainbowCnt });
}

//블록 제거
void EraseBlock(int startx, int starty) {
	queue<Pos>q;
	q.push({ startx,starty });
	int color = Map[startx][starty];
	Map[startx][starty] = -2;
	while (!q.empty()) {
		int x = q.front().x;
		int y = q.front().y;
		q.pop();
		for (int i = 0; i < 4; i++) {
			int nx = x + dx[i];
			int ny = y + dy[i];
			if (nx<0 || nx>=N || ny<0 || ny>=N)
				continue;
			//다음 블록이 무지개블록이거나 같은 블록이면
			if (Map[nx][ny] == 0 || Map[nx][ny] == color) {
				Map[nx][ny] = -2;
				q.push({ nx,ny });
			}
		}
	}
}

//중력 작용
void Gravity() {
	for (int i = N - 2; i >= 0; i--) {
		for (int j = 0; j < N; j++) {
			//검은 블록이거나 없으면
			if (Map[i][j] == -1 || Map[i][j] == -2)
				continue;
			int x = i + 1;
			//다른 블록 있을 때까지
			while (Map[x][j] == -2 && x < N) {
				x++;
			}
			//다른 블록이 있거나 범위 밖
			x--;
			if (Map[x][j] == -2) {
				Map[x][j] = Map[i][j];
				Map[i][j] = -2;
			}
		}
	}
}

void Rolling() {
	vector<int>tmp;
	int start = 0;
	int dest = N;
	while (start<N/2) {
		//위 블록 저장
		for (int i = start; i < dest ; i++) {
			tmp.push_back(Map[start][i]);
		}
		//오->위
		for (int i = start; i < dest ; i++) {
			Map[start][i] = Map[i][dest - 1];
		}
		//아래->오
		for (int i = dest - 1; i >= start; i--) {
			Map[dest - 1 - i+start][dest - 1] = Map[dest - 1][i];
		}
		//왼->아래
		for (int i = dest - 1; i >= start; i--) {
			Map[dest - 1][i] = Map[i][start];
		}
		//위->왼
		int d = 0;
		for (int i = dest - 1; i >= start; i--) {
			Map[i][start] = tmp[d++];
		}
		start++;
		dest--;
		tmp.clear();
	}
}

int main() {
	cin >> N >> M;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			cin >> Map[i][j];
		}
	}
	while (1) {
		//블록 그룹 존재하는지도 확인
		//크기 가장 큰 블록 찾기
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				memset(rvisited, false, sizeof(rvisited));
				if (Map[i][j] > 0 && visited[i][j]==false) {
					getInfo(i, j);
				}
			}
		}
		/*
		cout << "초기" << '\n' << '\n';
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				cout << Map[i][j] << ' ';
			}
			cout << '\n';
		}cout << '\n';
		*/
		//그룹 없으면 끝
		if (group.size()==0)
			break;

		//크기 가장 큰 그룹이 앞에 오도록 정렬
		sort(group.begin(), group.end(), sortGroup);

		//가장 큰 그룹 블록 삭제, 점수 획득
		EraseBlock(group[0].x, group[0].y);
		//cout << group[0].s << '\n';
		Score += pow(group[0].s, 2);
		//cout << "score : " << Score << '\n' << '\n';
		/*
		cout << "제거" << '\n' << '\n';
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				cout << Map[i][j] << ' ';
			}
			cout << '\n';
		}cout << '\n';
		*/
		//중력
		Gravity();
		/*
		cout << "중력" << '\n' << '\n';
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				cout << Map[i][j] << ' ';
			}
			cout << '\n';
		}cout << '\n';
		*/
		//90도 반시계 방향 회전
		Rolling();
		/*
		cout << "회전" << '\n' << '\n';
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				cout << Map[i][j] << ' ';
			}
			cout << '\n';
		}cout << '\n';
		*/
		//중력
		Gravity();
		/*
		cout << "중력2" << '\n' << '\n';
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				cout << Map[i][j] << ' ';
			}
			cout << '\n';
		}cout << '\n';
		*/
		memset(visited, false, sizeof(visited));
		group.clear();
	}
	cout << Score<< '\n';
	return 0;
}

(c++)백준 21608번: 상어 초등학교

Nimgnoej — Sun, 5 Sep 2021 15:15:20 +0900

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

21608번: 상어 초등학교

상어 초등학교에는 교실이 하나 있고, 교실은 N×N 크기의 격자로 나타낼 수 있다. 학교에 다니는 학생의 수는 N2명이다. 오늘은 모든 학생의 자리를 정하는 날이다. 학생은 1번부터 N2번까지 번호

www.acmicpc.net

[풀이]

|r1 - r2| + |c1 - c2| = 1을 만족하는 두 칸 (r1, c1)과 (r2, c2)를 인접한 칸이라고 한다. => 어떤 칸의 상하좌우에 있는 칸이 인접한 칸이다.

학생의 번호와 그 학생이 좋아하는 학생들의 번호를 저장하는 struct 자료구조를 만들어 입력을 받아 순서대로 어디에 자리를 배치할지 탐색한다.

빈칸들마다 주변에 좋아하는 학생 수, 빈칸 수를 저장하여 조건에 맞게 정렬한다. 정렬했을 때 제일 앞에 있는 좌표에 해당 학생을 배치시킨다.

모든 학생을 배치시키고 각 학생의 주변 학생을 확인한 다음 만족도의 총 합을 구한다.

[코드]

#include <iostream>
#include <algorithm>//sort
#include <vector>
#include <map>
#include <cmath>//pow
using namespace std;

struct Stu {
	int num;//학생 번호
	int favorite[4];//좋아하는 4명
};

struct Loc {
	int x, y;//좌표
	int fav;//인접한 칸에 좋아하는 학생 수
	int blank;//인접한 비어있는 칸 수
};

bool sortLoc(Loc &A, Loc &B) {
	//좋아하는 학생 수가 같으면
	if (A.fav == B.fav) {
		//빈칸 개수가 같으면
		if (A.blank == B.blank) {
			//행이 같으면
			if (A.x == B.x) {
				//열이 작은 칸
				return A.y < B.y;
			}
			//행이 작은 칸
			else
				return A.x < B.x;
		}
		//빈칸 개수가 많은 칸
		return A.blank > B.blank;
	}
	//좋아하는 학생 수가 많은 칸
	return A.fav > B.fav;
}

int N;
int Map[21][21] = {0,};
Stu student[400];
vector<Loc>Class;
bool filled[21][21] = { false, };
int dx[] = { -1,1,0,0 };
int dy[] = { 0,0,-1,1 };
map<int, int>m;

//학생 배치하기
void Place(int num, int favorite[4]) {
	Class.clear();
	//자리 차있으면 pass
	//각각 빈칸의 인접한 칸에 좋아하는 학생 몇명인지, 빈칸 몇개인지 세기
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			if (Map[i][j] != 0)
				continue;
			int fav_cnt = 0;
			int blank_cnt = 0;
			for (int d = 0; d < 4; d++) {
				int nx = i + dx[d];
				int ny = j + dy[d];
				//범위 확인
				if (nx <= 0 || nx > N || ny <= 0 || ny > N)
					continue;
				//빈칸이면
				if (Map[nx][ny] == 0)
					blank_cnt++;
				//아니면 좋아하는 학생인지 확인
				else {
					for (int n = 0; n < 4; n++) {
						if (Map[nx][ny] == favorite[n]) {
							fav_cnt++;
							break;
						}
					}
				}
			}
			Class.push_back({ i,j,fav_cnt,blank_cnt });
		}
	}
	sort(Class.begin(), Class.end(), sortLoc);
	int x = Class[0].x;
	int y = Class[0].y;
	Map[x][y] = num;
	return;
}

int main() {
	cin >> N;
	int num;
	int fav[4];
	for (int i = 0; i < N*N; i++) {
		cin >> student[i].num;
		//배열 student의 몇 번째 칸에 num의 좋아하는 학생 배열 있는지 저장
		m.insert(make_pair(student[i].num, i));
		for (int j = 0; j < 4; j++) {
			cin >> student[i].favorite[j];
		}
	}
	for (int i = 0; i < N*N; i++) {
		Place(student[i].num,student[i].favorite);
	}
	int answer = 0;
	//만족도 구하기
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			int num = Map[i][j];
			int fav_cnt = 0;
			for (int d = 0; d < 4; d++) {
				int nx = i + dx[d];
				int ny = j + dy[d];
				if (nx <= 0 || nx > N || ny <= 0 || ny > N)
					continue;
				for (int n = 0; n < 4; n++) {
					if (Map[nx][ny] == student[m[num]].favorite[n]) {
						fav_cnt++;
						break;
					}
				}
			}
			if (fav_cnt == 0)
				continue;
			answer += pow(10, fav_cnt - 1);
		}
	}
	cout << answer << '\n';
	return 0;
}

(c++)백준 2671번: 잠수함식별

Nimgnoej — Fri, 9 Jul 2021 20:22:32 +0900

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

2671번: 잠수함식별

입력에 들어있는 스트링을 읽고, 이것이 잠수함의 엔진소리를 나타내는 스트링인지 아니면 그냥 물속의 잡음인지를 판정한 후, 잠수함의 엔진 소리에 해당하는 스트링이면 "SUBMARINE"을 출력하고

www.acmicpc.net

[풀이]

regex정규표현식을 사용하여 문제를 풀었다. 문제의 엔진소리 패턴을 문자열로 정의해두고, 입력된 문자열이 패턴과 같으면 "SUBMARINE"을, 그렇지 않으면 "NOISE"를 출력하도록 하였다.

#include <iostream>
#include <regex>//정규표현식
#include <string>
using namespace std;

string str;

int main() {
	cin >> str;
	string engine = "(100+1+|01)+";
	if (regex_match(str, regex(engine)))
		cout << "SUBMARINE\n";
	else
		cout << "NOISE\n";
	return 0;
}

(c++)백준 1920번: 수 찾기

Nimgnoej — Thu, 8 Jul 2021 21:02:33 +0900

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

1920번: 수 찾기

첫째 줄에 자연수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 N개의 정수 A[1], A[2], …, A[N]이 주어진다. 다음 줄에는 M(1 ≤ M ≤ 100,000)이 주어진다. 다음 줄에는 M개의 수들이 주어지는데, 이 수들

www.acmicpc.net

[풀이]

이분탐색을 사용하여 풀었다.

※이분탐색을 하려면 배열 A를 정렬시켜야 하므로 vector자료구조를 사용하였다.

#include <iostream>
#include <vector>
#include <algorithm>//sort
using namespace std;

int N, M;
vector<int>A;

void Search(int n) {
	int front = 0, rear = N - 1;
	while (front <= rear) {
		int mid = (front + rear) / 2;
		
		if (A[mid] == n) {
			cout << 1 << '\n';
			return;
		}
		else if (A[mid] < n) {
			front = mid + 1;
		}
		else if (A[mid] > n) {
			rear = mid - 1;
		}
	}
	cout << 0 << '\n';
	return;
}

int main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	int n;
	cin >> N;
	for (int i = 0; i < N; i++) {
		cin >> n;
		A.push_back(n);
	}
	//이분탐색을 하려면 정렬되어 있어야 한다!
	sort(A.begin(), A.end());
	cin >> M;
	for (int i = 0; i < M; i++) {
		cin >> n;
		Search(n);
	}
	return 0;
}

(c++)백준 2003번: 수들의 합 2

Nimgnoej — Fri, 23 Apr 2021 18:39:22 +0900

www.acmicpc.net/problem/2003

2003번: 수들의 합 2

첫째 줄에 N(1 ≤ N ≤ 10,000), M(1 ≤ M ≤ 300,000,000)이 주어진다. 다음 줄에는 A[1], A[2], …, A[N]이 공백으로 분리되어 주어진다. 각각의 A[x]는 30,000을 넘지 않는 자연수이다.

www.acmicpc.net

[풀이]

투포인터로 풀 수 있는 문제였다.

투포인터는 하나의 배열에 두 개의 포인터를 사용하는 알고리즘으로, 배열의 원소가 모두 자연수이므로 사용할 수 있었다.

1. start와 end포인터를 0으로 초기화

2. 합이 M보다 작으면 end포인터를 이동시켜 값을 크게 해주기

3. M보다 크면 start포인터를 이동시켜 값을 작게 해주기

4. M과 같으면 count + 1, start포인터 이동시키기

#include <iostream>
using namespace std;

int N, M;
int A[10001];

int countM() {
	int cnt = 0;
	int startx = 0;
	int endx = 0;
	int sum = 0;
	while (endx <= N) {
		if (sum < M) {
			sum += A[endx];
			endx++;
		}
		if (sum >= M) {
			if (sum == M)
				cnt++;
			sum -= A[startx];
			startx++;
		}
	}
	return cnt;
}

int main() {
	cin >> N >> M;
	for (int i = 0; i < N; i++) {
		cin >> A[i];
	}
	cout << countM() << '\n';
	return 0;
}

+ 투포인터 말고 dfs로도 풀 수 있었다. (투포인터 방법보다 시간복잡도가 더 큰 방법)(투포인터 : 4ms, dfs : 32ms)

//dfs조합으로 풀어보기
#include <iostream>
using namespace std;

int N, M;
int A[10001];
bool check[10001];
int cnt = 0;

void dfs(int x, int sum) {
	if (sum > M)
		return;
	if (sum == M) {
		cnt++;
		return;
	}
	if (x >= N)
		return;
	dfs(x + 1, sum + A[x]);
}

int main() {
	cin >> N >> M;
	for (int i = 0; i < N; i++) {
		cin >> A[i];
	}
	for (int i = 0; i < N; i++) {
		dfs(i, 0);
	}
	cout << cnt << '\n';
	return 0;
}

(C++)백준 20061번: 모노미노도미노 2

Nimgnoej — Wed, 21 Apr 2021 16:58:22 +0900

www.acmicpc.net/problem/20061

20061번: 모노미노도미노 2

모노미노도미노는 아래와 같이 생긴 보드에서 진행되는 게임이다. 보드는 빨간색 보드, 파란색 보드, 초록색 보드가 그림과 같이 붙어있는 형태이다. 게임에서 사용하는 좌표 (x, y)에서 x는 행,

www.acmicpc.net

[풀이]

문제에 적힌 조건들을 구현하는 문제였다.

빨간색 보드와 초록색, 파란색 보드를 모두 한 배열로 구현하지 않고, 6*4초록색보드 배열과 4*6파란색보드 배열을 따로 만들어 사용했다.

블록을 놓은 위치를 받아 먼저 초록색 보드와 파란색 보드에 블록을 옮겨줬다. 그리고 while문을 두 개 중첩하여 먼저 해이나 열이 타일로 가득 찬 경우가 없을 때까지 점수를 획득하도록 하였다.

꽉찬 행이나 열이 없으면 특별한 칸에 블록이 있는지, 있으면 몇행 또는 몇열을 차지하는지 반환하여 초록색 보드의 경우는 5-(연한칸의 블록이 있는 행 개수)행부터 그 행의 개수만큼 아래로 내려줬고, 파란색 보드는 같은 연산을 행을 열로 바꾸어서 해주었다.

※특별한 칸에 블록이 있는 경우 그 개수를 세서 모든 행이나 열에 대해 한번에 내려주지 않으면 시간초과가 난다!

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

struct Pos {
	int t;
	int x, y;
};

int N;
int Green[6][4];
int Blue[4][6];
vector<Pos>Block;//블록 놓은 정보
int score = 0;

void greenBlock(int t, int y) {
	//1*1
	if (t == 1) {
		int gx = 0;
		while (gx < 6) {
			if (Green[gx][y] != 0)
				break;
			gx++;
		}
		gx--;
		Green[gx][y] = 1;
	}
	//1*2
	else if (t == 2) {
		int gx = 0;
		while (gx < 6) {
			if (Green[gx][y] != 0 || Green[gx][y + 1] != 0)
				break;
			gx++;
		}
		gx--;
		Green[gx][y] = 1;
		Green[gx][y + 1] = 1;
	}
	//2*1
	else if (t == 3) {
		int gx = 0;
		while (gx < 5) {
			if (Green[gx][y] != 0 || Green[gx + 1][y] != 0)
				break;
			gx++;
		}
		gx--;
		Green[gx][y] = 1;
		Green[gx + 1][y] = 1;
	}
}

void blueBlock(int t,int x) {
	//1*1
	if (t == 1) {
		int gy = 0;
		while (gy < 6) {
			if (Blue[x][gy] != 0)
				break;
			gy++;
		}
		gy--;
		Blue[x][gy] = 1;
	}
	//1*2
	else if (t == 2) {
		int gy = 0;
		while (gy < 5) {
			if (Blue[x][gy] != 0 || Blue[x][gy + 1] != 0)
				break;
			gy++;
		}
		gy--;
		Blue[x][gy] = 1;
		Blue[x][gy + 1] = 1;
	}
	//2*1
	else if (t == 3) {
		int gy = 0;
		while (gy < 6) {
			if (Blue[x][gy] != 0 || Blue[x + 1][gy] != 0)
				break;
			gy++;
		}
		gy--;
		Blue[x][gy] = 1;
		Blue[x + 1][gy] = 1;
	}
}

//초록색보드에서 타일로 가득 찬 행 찾기
int greenFull() {
	bool go_next = false;
	for (int i = 0; i < 6; i++) {
		go_next = false;
		for (int j = 0; j < 4; j++) {
			if (Green[i][j] == 0) {
				go_next = true;
				break;
			}
		}
		if(go_next==false)
			return i;
	}
	return -1;
}

int blueFull() {
	bool go_next = false;
	for (int i = 0; i < 6; i++) {
		go_next = false;
		for (int j = 0; j < 4; j++) {
			if (Blue[j][i] == 0) {
				go_next = true;
				break;
			}
		}
		if (go_next == false)
			return i;
	}
	return -1;
}

void greenRemove(int r) {
	for (int i = 0; i < 4; i++) {
		Green[r][i] = 0;
	}
	//밑으로 내리기
	for (int i = r - 1; i >= 0; i--) {
		for (int j = 0; j < 4; j++) {
			Green[i + 1][j] = Green[i][j];
		}
	}
}

void blueRemove(int c) {
	for (int i = 0; i < 4; i++) {
		Blue[i][c] = 0;
	}
	//밑으로 내리기
	for (int i = c - 1; i >= 0; i--) {
		for (int j = 0; j < 4; j++) {
			Blue[j][i + 1] = Blue[j][i];
		}
	}
}

//초록색 보드의 연한 칸에 블록이 있는지
int greenSpecial() {
	int cnt = 0;
	for (int i = 0; i <= 1; i++) {
		for (int j = 0; j < 4; j++) {
			if (Green[i][j] == 1) {
				cnt++;
				break;
			}
		}
	}
	return cnt;
}

//파란색 보드의 연한 칸에 블록이 있는지
int blueSpecial() {
	int cnt = 0;
	for (int i = 0; i <= 1; i++) {
		for (int j = 0; j < 4; j++) {
			if (Blue[j][i] == 1) {
				cnt++;
				break;
			}
		}
	}
	return cnt;
}

void putBlock() {
	for (int i = 0; i < N; i++) {
		int t = Block[i].t;
		int x = Block[i].x;
		int y = Block[i].y;
		//초록색 보드에 블럭 내리기
		greenBlock(t, y);
		//파란색 보드에 블럭 내리기
		blueBlock(t, x);
		while (1) {
			//초록색 보드에서 행이 가득 찬 경우가 없을 때까지 점수 획득
			while (1) {
				int r = greenFull();
				//꽉 찬 행이 없으면
				if (r == -1)
					break;
				score++;
				greenRemove(r);
			}
			//초록색 보드의 연한 칸에 블록이 있는지
			int cnt = greenSpecial();
			if (cnt == 0)
				break;
			for (int row = 5 - cnt; row >= 0; row--) {
				for (int col = 0; col < 4; col++) {
					Green[row + cnt][col] = Green[row][col];
					Green[row][col] = 0; 
				}
			}
		}
		//파란색 보드
		while (1) {
			//파란색 보드에서 행이 가득 찬 경우가 없을 때까지 점수 획득
			while (1) {
				int c = blueFull();
				//꽉 찬 열이 없으면
				if (c == -1)
					break;
				score++;
				blueRemove(c);
			}
			//파란색 보드의 연한 칸에 블록이 있는지
			int cnt = blueSpecial();
			if (cnt == 0)
				break;
			for (int col = 5 - cnt; col >= 0; col--) {
				for (int row = 0; row < 4; row++) {
					Blue[row][col + cnt] = Blue[row][col];
					Blue[row][col] = 0;
				}
			}
		}
	}
}

int main() {
	ios_base::sync_with_stdio(0);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> N;
	int t, x, y;
	for (int i = 0; i < N; i++) {
		cin >> t >> x >> y;
		Block.push_back({ t,x,y });
	}
	putBlock();
	cout << score << '\n';
	int block_cnt = 0;
	for (int i = 0; i < 6; i++) {
		for (int j = 0; j < 4; j++) {
			if (Green[i][j] == 1)
				block_cnt++;
			if (Blue[j][i] == 1)
				block_cnt++;
		}
	}
	cout << block_cnt << '\n';
}

(c++)백준 15686번: 치킨 배달

Nimgnoej — Sat, 10 Apr 2021 11:08:56 +0900

www.acmicpc.net/problem/15686

15686번: 치킨 배달

크기가 N×N인 도시가 있다. 도시는 1×1크기의 칸으로 나누어져 있다. 도시의 각 칸은 빈 칸, 치킨집, 집 중 하나이다. 도시의 칸은 (r, c)와 같은 형태로 나타내고, r행 c열 또는 위에서부터 r번째 칸

www.acmicpc.net

[풀이]

치킨집 M개 조합을 구하여 각각 집에 대해 가장 작은 치킨거리를 더하는 문제였다.

처음에 치킨집 M개 위치를 dfs조합으로 구하고, bfs로 각 집에서 시작하여 가장 가까운 치킨집을 구하려고 했는데 시간초과가 나왔다..

알고보니 각각 집에 대해서 M개의 치킨집까지의 치킨거리를 모두 구하여 가장 작은 수를 더해주면 되는 거였다..!

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>//min
#include <cstring>//memset
#include <cmath>//abs
using namespace std;

struct Pos {
	int x, y;
};

int N, M;
bool check[13];
vector<Pos>House;//입력받은 집
vector<Pos>Pick;//선택받은 치킨집
vector<Pos>Chicken;//입력받은 치킨집
int Min = 987654321;


//M개 치킨집 조합 구하기
void getChicken(int x, int cnt) {
	if (cnt == M) {
		int res = 0;
		for (int i = 0; i < House.size(); i++) {
			int min_dist = 987654321;
			//각 집에서 가장 가까운 치킨집 찾기
			for (int j = 0; j < Pick.size(); j++) {
				min_dist = min(min_dist, abs(House[i].x - Pick[j].x) + abs(House[i].y - Pick[j].y));
			}
			res += min_dist;
		}
		Min = min(Min, res);
		return;
	}
	for (int i = x; i < Chicken.size(); i++) {
		if (check[i] == true)
			continue;
		check[i] = true;
		Pick.push_back({ Chicken[i].x,Chicken[i].y });
		getChicken(i, cnt + 1);
		check[i] = false;
		Pick.pop_back();
	}
}

int main() {
	cin >> N >> M;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			int n;
			cin >> n;
			if (n == 1)
				House.push_back({ i,j });
			else if (n == 2)
				Chicken.push_back({ i,j });
		}
	}
	getChicken(0, 0);
	cout << Min << '\n';
	return 0;
}

(c++)백준 15685번: 드래곤 커브

Nimgnoej — Fri, 9 Apr 2021 14:54:17 +0900

www.acmicpc.net/problem/15685

15685번: 드래곤 커브

첫째 줄에 드래곤 커브의 개수 N(1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 드래곤 커브의 정보가 주어진다. 드래곤 커브의 정보는 네 정수 x, y, d, g로 이루어져 있다. x와 y는 드래곤 커

www.acmicpc.net

[풀이]

처음 문제를 봤을 때 참 난감한 문제였다.. 시뮬레이션 구현 문제는 규칙이 있기 마련이기에 손으로 그려보면서 규칙을 찾았다.

먼저 각 방향이 다음세대를 그릴 때 어떻게 바뀌는지 찾았다.

방향은 아래와 같이 바뀐다.

0 → 1 (→ ↑)

1 → 2 (↑ ←)

2 → 3 (← ↓)

3 → 0 (↓ →)

그리고 다음세대에 새로 그려지는 드래곤 커브가 어떤 순서로 그려지는 지 찾았다. 앞세대의 드래곤 커브를 복사하여 끝 부분에 붙인다고 했을 때, 앞 세대에서 가장 마지막에 그려진 것부터 역순으로 그려진다.

아래 그림과 같이 대응된다.

위의 규칙들을 따라서 드래곤 커브를 그릴때마다 그 방향들을 다음세대를 위해 저장하고, 다음 세대를 그릴 때 가장 마지막에 저장된 방향부터 방향 규칙에 따라 변경후 드래곤 커브를 그려주면 된다.

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

int N;
int Grid[101][101] = { 0, };
const int dxy[][2] = { {0,1},{-1,0},{0,-1},{1,0} };//0:오른쪽, 1:위, 2:왼쪽, 3:아래
int convert[] = { 1,2,3,0 };
vector<int>dir;

void DragonCurve(int cnt, int g, int x, int y) {
	if (cnt == g + 1) {
		return;
	}
	int nx = x;
	int ny = y;
	int dir_size = dir.size();
	for (int d = dir_size - 1; d >= 0; d--) {
		int nd = convert[dir[d]];
		nx += dxy[nd][0];
		ny += dxy[nd][1];
		dir.push_back(nd);//다음 세대 위해 현재 방향 정보 저장
		Grid[nx][ny] = 1;//드래곤 커브 지나감
	}
	DragonCurve(cnt + 1, g, nx, ny);
}

int getSquare() {
	int cnt = 0;
	/*
	cout << '\n';
	for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			cout << Grid[i][j] << ' ';
		}
		cout << '\n';
	}
	*/
	for (int i = 0; i < 100; i++) {
		for (int j = 0; j < 100; j++) {
			if (Grid[i][j] == 1 && Grid[i][j + 1] == 1 && Grid[i + 1][j] == 1 && Grid[i + 1][j + 1] == 1)
				cnt++;
		}
	}
	return cnt;
}

int main() {
	cin >> N;
	int x, y, d, g;
	while (N--) {
		dir.clear();
		cin >> y >> x >> d >> g;
		//0세대 미리 해주기(두 칸 칠해줘야 하므로!)
		Grid[x][y] = 1;
		x += dxy[d][0];
		y += dxy[d][1];
		Grid[x][y] = 1;
		if (g == 0)
			continue;
		dir.push_back(d);
		//1세대부터 시작
		DragonCurve(1, g, x, y);
	}
	cout << getSquare() << '\n';
	return 0;
}