재시민

www.acmicpc.net/problem/1018

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

int main(void) {
	int Col; int Row;
	cin >> Col >> Row;

	vector<char> chess(51,0);
	vector<vector<char>> chessSpace(51,vector<char>(51,0));
	vector<char> chess1(51, 0);
	vector<vector<char>> chessSpace1(51, vector<char>(51, 0));

	vector<char> compare(51, 0);
	vector<vector<char>> chessCompare(51, vector<char>(51, 0));
	int i, j;
	for (i = 0;i < 8;i++) {
		for (j = 0;j < 8;j++) {
			if (i + j == 0 || (i + j) % 2 == 0) {// 0 이거나 2의 배수
				chessSpace[i][j] = 'W';
				chessSpace1[i][j] = 'B';
			}
			else {
				chessSpace[i][j] = 'B';
				chessSpace1[i][j] = 'W';
			}
		}
	}
	for (i = 0;i < Col;i++) {
		for (j = 0;j < Row;j++) {
			char A;
			cin >> A;
			chessCompare[i][j] = A;
		}
	}
	int count = 0;
	int count1 = 0;
	int ai, aj;
	
	vector<int> counter;
	for (ai = 0;ai <= Col - 8;ai++) {
		for (aj = 0;aj <= Row - 8;aj++) {
			int bi = 0; int bj = 0;
			for (i = ai;i < ai + 8;i++) {
				for (j = aj;j < aj + 8;j++) {
					if (chessSpace[bi][bj] != chessCompare[i][j]) {
						count++;
					}
					if (chessSpace1[bi][bj] != chessCompare[i][j]) count1++;
					if (bj <= 8)bj++;
				}if(bi<=8)bi++;
				 bj = 0;
			}counter.push_back(count);
			counter.push_back(count1);
			count = 0;
			count1 = 0;
			 bi = 0; 
		}
	}
	int min = *min_element(counter.begin(), counter.end());
	cout << min;
	return 0;
}

너무 코드가 더럽다

이게 최선인가 싶다.

1. 비교할 체스판 2개 생성

2. 기준점을 바꿔가면서 목표 체스판과 비교 후 count push

3. 최솟값 출력

www.acmicpc.net/problem/1708

수업시간에 배운 내용이라 복습겸 풀어보았다.

짐꾸리기로 풀다가 3시간은 날린 것 같다. 

다른 사람들 코드를 보니 거의 다 아니 모두가 Graham Scan 으로 푼 것 같다.

탈진 상태가 되고 배우는 마음으로 코드를 학습했다.

#include<iostream> 
#include<vector>
#include<algorithm>
#include<stack>
using namespace std;
typedef long long int ll;
struct pos
{
	ll x, y;
};
vector<pos> vec;
bool compare_pos(pos p1, pos p2)
{
	if (p1.y != p2.y)
	{
		return p1.y < p2.y;
	}
	else
	{
		return p1.x < p2.x;
	}
}
long long int ccw(pos p1, pos p2, pos p3)//외적공식
{
	//음수 시계 
	//양수 반시계 
	//0 평행
	return (p1.x * p2.y + p2.x * p3.y + p3.x * p1.y - (p1.y * p2.x + p2.y * p3.x + p3.y * p1.x));
}

bool compare_rad(pos p1, pos p2)// 라디안 비교 가장큰거
{
	long long int cc = ccw(vec[0], p1, p2);
	if (cc)//라디안이 비교가능
		return cc > 0;
	else//라디안이 동일 , 수평일때
		return p1.x + p1.y < p2.x + p2.y; // 가장큰순서대로
}

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


	cin >> N;
	for (int i = 0; i < N; i++)
	{
		ll y, x;
		cin >> x >> y;
		vec.push_back({ x,y });
	}
	stack<pos> sta;
	sort(vec.begin(), vec.end(), compare_pos);
	sort(vec.begin() + 1, vec.end(), compare_rad);
	sta.push(vec[0]);//비교를 위한 최소 점 셋팅
	sta.push(vec[1]);
	pos first, second;
	for (int i = 2; i < N; i++)
	{
		while (sta.size() >= 2)
		{
			second = sta.top();
			sta.pop();
			first = sta.top();
			if (ccw(first, second, vec[i]) > 0)
			{
				sta.push(second);
				break;
			}
		}
		sta.push(vec[i]);
	}
	cout << sta.size();
}

다른 분의 코드를 거의 배꼈다. 정말 수치심이 든다.

하지만 이렇게 배워간다면 다른 문제를 풀 수 있는 발판이 된다면 오히려 괜찮을지도..?

원 코드는 ccw 의 함수 때문에 테스트 값에서 오류가 나 long long int 로 재정의 하였다. 

사실 문제 안에 변들의 180도를 넘지 않는 가장 큰 각도를 선정해서 볼록껍질을 만들라는 말이 있었다.

나는 이것을 싸그리 무시하고 짐꾸리기를 배웠으니 그렇게 해야지 라고 해서 못한 것 같다.

일찌감치 인정하고 다른 방법으로 풀었어야 했는데..

알고리즘 설명

1. 벡터안에 입력한 순서쌍들을 push_back 한다.

2. 기준점을 설정할 정렬을 한다.

3. 기준점을 잡고 나머지 점들과 ccw 의 결과를 이용한 정렬을 한다. 이때, ccw = 0 인 점이 존재한다면 x+y 값이 더큰 점에 true 를 부여한다. 

4. 스택에 기준점, 비교할 점 두개를 push 한다. 왜냐하면, ccw 를 하기 위한 최소조건이다.

5. 스택의 맨 뒤 원소 두개와 벡터의 모든 원소 ccw 한 값을 비교하면서 ccw 값이 양수인 점을 찾고 맞으면 push 아니면 break 한다.

6. 반복문이 종료되면 스택에는 꼭짓점이 될 점들만 남는다. 

www.acmicpc.net/problem/11758

수업시간에 세 점이 이루는 꺾인선의 방향을 구해 교차여부를 알아내는 방법을 배웠다.

기억을 위해 거의 비슷한 문제로 복습을 해보았다.

#include<iostream>

using namespace std;

struct point {
	int x;
	int y;
}first, second;

struct line {
	struct point p1;
	struct point p2;
}testLine;

int direction(struct point A, struct point B, struct point C) {
	int dxAB, dxAC, dyAB, dyAC, Dir;
	dxAB = B.x - A.x; dxAC = C.x - A.x;
	dyAB = B.y - A.y; dyAC = C.y - A.y;

	if (dxAB * dyAC < dyAB * dxAC) Dir = -1;
	if (dxAB * dyAC > dyAB * dxAC) Dir = 1;
	if (dxAB * dyAC == dyAB * dxAC) {
		/*if (dxAB == 0 && dyAB == 0) Dir = 0;
		if ((dxAB * dxAC < 0) || (dyAB * dyAC < 0)) Dir = 1;
		else if ((dxAB * dxAB + dyAB * dyAB) >= (dxAC * dxAC + dyAC * dyAC)) Dir = 0;
		else Dir = -1;*/
		Dir = 0;
	}
	return Dir;
}

int main(void) {
	struct point A;
	struct point B;
	struct point C;

	int i,x, y;

	
	cin >> x >> y;
	A.x = x;
	A.y = y;
	cin >> x >> y;
	B.x = x;
	B.y = y;
	cin >> x >> y;
	C.x = x;
	C.y = y;
	

	cout <<direction(A, B, C);
	
	return 0;
}

이 문제는 세 점이 한 직선위에 존재한다는 가정을 뺀 상태이므로 세 점의 중간점이 무엇인지에 대한 부분은 주석처리 

했다.

www.acmicpc.net/step/34

고등 확률과 통계에서 배우는 순열과 조합이다.

순열과 조합을 구현하는데에 있어 매번 구글링 하기 귀찮아 좋은 정보를 얻어 정리를 해보려고한다.

출처 : hongchan.tistory.com/5

덕분에 좋은 정보를 얻었다.

순열 nPr

void printArray(int a[], int r) {
    for (int i = 0;i < r;i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
}

void permutation(int pArr[], bool check[], int n, int r, int depth) {
    if (depth == r) {
        printArray(pArr, r);
        return;
    }

    for (int i = 1; i <= n; i++) {
        if (!check[i]) {
            check[i] = true;
            pArr[depth] = i;
            permutation(pArr, check, n, r, depth + 1);
            check[i] = false;
        }
    }
}

int main(void) {

    int n, r;
    cin >> n >> r;
    int* pArr = new int[r];
    bool* check = new bool[n + 1];
    for (int i = 0;i < r;i++) {
        pArr[i] = 0;
    }
    for (int i = 0;i < n + 1;i++) {
        check[i] = false;
    }
    permutation(pArr, check, n, r, 0);

    return 0;
}

1. pArr[] : n 까지의 숫자의 경우를 저장할 배열
2. check[] : 순열에서 중복의 여부를 확인하는 배열 ( 이 배열을 뺀다면 중복 순열이 된다. )

알고리즘 설명

1. check 가 false 인지 확인 ( 이미 나온 숫자인가? )
2. false 이면 true 로 할당
3. pArr[] 에 i 할당 ( 1부터 저장하기 위해 i = 1 로 지정 )
4. Permutation(...,depth + 1) 실행하여 중복되지 않는 수를 확인하고 배열에 삽입
5. depth == r 이 된다면 pArr 에 있는 원소 모두 출력
6. check 를 차례대로 false 로 할당하면서 함수 빠져나옴
7. for 문 반복

조합 nCr

void combination(int pArr[], int n, int r, int depth, int next) {
    if (depth == r) {
        printArray(pArr, r);
        return;
    }

    for (int i = next; i <= n; i++) {
        pArr[depth] = i;
        combination(pArr,n, r, depth + 1, i+1);// i+1 을 i로 바꿔주면 중복 허용
    }
}

int main(void) {

    int n, r;
    cin >> n >> r;
    int* pArr = new int[r];
    for (int i = 0;i < r;i++) {
        pArr[i] = 0;
    }
    combination(pArr, n, r, 0, 1);

    return 0;
}

순열과 다른 점 

• 조합은 순열과 달리 오름차순으로 정렬이 된다.

따라서, for 문의 i 값이 combination 이 실행될 수록 이 전 i 값보다 커야한다.

그리고, check[] 배열을 사용하지 않는 이유는 i 값을 늘려줌으로써 이전의 i 값이나 동일한 값이 들어가지 않기 때문이다.

그래서, i 의 값을 유지시킨다면 중복 조합이 된다. 

재귀로된 순열과 조합을 설명해 보았다.

하지만, 재귀인만큼 큰 수로 접근하게 된다면 overflow 발생 가능성도 있고 무엇보다 느리다.

이와 관련된 문제를 풀었었는데 까먹었다. ㅎㅎ