글 읽기 - 10875번 뱀 문제 40% 틀렸습니다 뜹니다..ㅠ 주석있어요!

nuckly 6년 전 0

도대체 왜 뭐가 틀렸는지 모르겠습니다..ㅠ
밑에 댓글들에있는 예제들은 전부다되는데.. 뭐가문제일까요
정확히 40%에서만 10번정도 수정하면서 틀리고있네요..ㅠㅠ
#include <stdio.h>
#include <math.h>
#include <vector>
#include <list>
using namespace std;

int XA[4] = {1, 0, -1, 0};
int YA[4] = {0, 1, 0, -1};

long long iValue[1000];
char cValue[1000];

typedef struct tagInfo
{
	long long  x[2];	//X축 [0] 선분의 시작 [1] 선분의 끝
	long long  y[2];	//Y축 [0] 선분의 시작 [1] 선분의 끝
	int h;				//선분의 방향
}INFO;

vector<INFO> v;
//vector<INFO> 에서는  그어진 선분의 시작점, 끝나는점을 push_back 을 통하여 가지고있는다.
list<long long > li;
//vector 를 돌리면서 여러가지가 부딫히는 케이스가 될경우 가장 가까운것을 확인해야 하므로
//list<long long> 에서는 현재 좌표로 방향이동을 할때 부딫히는 모든 선분들과의 거리를 가지고 있으며
//그중 가장 작은값을 찾기위해 사용
int main()
{
	long long iCount = 0;
	long long MapLimit;
	scanf("%lld", &MapLimit);
	MapLimit+= 1;
	int N;
	scanf("%d", &N);
	long long X = 0;
	long long Y = 0;
	int iHandle = 0;
	INFO a;
	a.x[0] = 0;
	a.y[0] = 0;
	a.x[1] = 0;
	a.y[1] = 0;
	for(int i = 0; i < 4; i++) {
		a.h = i;
		v.push_back(a); // 맨처음 0,0 에 대하여 4방향 모두다 push_back
	}

	for(int i = 0; i < N; i++)
		scanf("%lld %c", &iValue[i], &cValue[i]);
	//처음 입력값 받기


	for(int i = 0; i < N; i++)
	{
		a.x[0] = X; // 처음 X, Y의 좌표를 a의 x[0] y[0] 에 넣는다.
		a.y[0] = Y;
		a.h = iHandle;
		X += XA[iHandle]*iValue[i]; //X와 Y를 이동시킨다.
		Y += YA[iHandle]*iValue[i];



		///////////////////////
		///////////////////////
		///////////////////////
		//Vector 돌리기 Map에 그어진 선분들 하나하나 확인
		///////////////////////
		///////////////////////
		///////////////////////
		//iHandle 의 값에따라
		// 0 우
		// 1 상
		// 2 좌
		// 3 하
		for(int j = 0; j < i+4; j++) { // 4방향 확인
			switch(v[j].h) { // 현재 vector 에 있는 선분의 방향 확인
			case 0:
				switch(iHandle) { // 현재 이동할 방향 확인
				case 0:
					if(Y == v[j].y[0]) // 선분 -> 방향 / 현재 -> 방향 일 때 Y축이 같으면서
					{
						if(v[j].x[0]-X <= 0 && a.x[0] < v[j].x[0]) // 현재 시작하는 좌표가 선분의 시작좌표보다 이전에 있을경우
						{
							li.push_back(iValue[i]- (X-v[j].x[0])); // li 리스트에 현 좌표로부터 부딫히는 좌표까지의 거리를 push)back
						}
					}
					break;
				case 1:
					if(X >= v[j].x[0] && X <= v[j].x[1])
					{
						if(v[j].y[0] - Y <= 0 && a.y[0] < v[j].y[0])
						{
							li.push_back(iValue[i]- (Y-v[j].y[0]));
						}
					}
					break;
				case 2:
					if(Y == v[j].y[0])
					{
						if(v[j].x[1]-X >= 0 &&  a.x[0] > v[j].x[1])
						{
							li.push_back(iValue[i]- (v[j].x[1]-X));
						}
					}
					break;
				case 3:
					if(X >= v[j].x[0] && X <= v[j].x[1])
					{
						if(v[j].y[0] - Y >= 0 && a.y[0] > v[j].y[0])
						{
							li.push_back(iValue[i]- (v[j].y[0] - Y));
						}
					}
					break;
				}
				break;
		//iHandle 의 값에따라
				// 0 우
				// 1 상
				// 2 좌
				// 3 하
			case 1:
				switch(iHandle) {
				case 0:
					if(Y >= v[j].y[0] && Y <= v[j].y[1])
					{
						if(v[j].x[0] - X <= 0 && a.x[0] < v[j].x[0])
						{
							li.push_back(iValue[i] - (X-v[j].x[0]));
						}
					}
					break;
				case 1:
					if(X == v[j].x[0])
					{
						if(v[j].y[0]-Y <= 0  && a.y[0] < v[j].y[0])
						{
							li.push_back(iValue[i]- (Y-v[j].y[0]));
						}
					}
					break;
				case 2:
					if(Y >= v[j].y[0] && Y <= v[j].y[1])
					{
						if(v[j].x[1] - X >= 0 && a.x[0] > v[j].x[0])
						{
							li.push_back(iValue[i] - (v[j].x[1] - X));
						}
					}
					break;
				case 3:
					if(X == v[j].x[0])
					{
						if(v[j].y[1]-Y >= 0 && a.y[0] > v[j].y[1])
						{
							li.push_back(iValue[i]- (v[j].y[1]-Y));
						}
					}
					break;
				}
				break;
		//iHandle 의 값에따라
				// 0 우
				// 1 상
				// 2 좌
				// 3 하
			case 2:
				switch(iHandle) {
				case 0:
					if(Y == v[j].y[0])
					{
						if(v[j].x[1]-X <= 0 && a.x[0] < v[j].x[1])
						{
							li.push_back(iValue[i]- (X-v[j].x[1]));
						}
					}
					break;
				case 1:
					if(X >= v[j].x[1] && X <= v[j].x[0])
					{
						if(v[j].y[0] - Y <= 0 && a.y[0] < v[j].y[0])
						{
							li.push_back(iValue[i] - (Y - v[j].y[0]));
						}
					}
					break;
				case 2:
					if(Y == v[j].y[0])
					{
						if(v[j].x[0]-X >= 0 && a.x[0] > v[j].x[0])
						{
							li.push_back(iValue[i]- (v[j].x[0]-X));
						}
					}
					break;
				case 3:
					if(X >= v[j].x[1] && X <= v[j].x[0])
					{
						if(v[j].y[0] - Y >= 0 && a.y[0] > v[j].y[0])
						{
							li.push_back(iValue[i] - (v[j].y[0] - Y));
						}
					}
					break;
				}
				break;
		//iHandle 의 값에따라
				// 0 우
				// 1 상
				// 2 좌
				// 3 하
			case 3:
				switch(iHandle) {
				case 0:
					if(Y >= v[j].y[1] && Y <= v[j].y[0])
					{
						if(v[j].x[0] - X <= 0 && a.x[0] < v[j].x[0])
						{
							li.push_back(iValue[i] - (X-v[j].x[0]));
						}
					}
					break;
				case 1:
					if(X == v[j].x[0])
					{
						if(v[j].y[1]-Y <= 0 && a.y[0] < v[j].y[1])
						{
							li.push_back(iValue[i]- (Y-v[j].y[0]));
						}
					}
					break;
				case 2:
					if(Y >= v[j].y[1] && Y <= v[j].y[0])
					{
						if(v[j].x[1] - X >= 0 && a.x[0] > v[j].x[1])
						{
							li.push_back(iValue[i] - (v[j].x[1] - X));
						}
					}
					break;
				case 3:
					if(X == v[j].x[0])
					{
						if(v[j].y[0]-Y >= 0 && a.y[0] > v[j].y[0])
						{
							li.push_back(iValue[i]- (v[j].y[0]-Y));
						}
					}
					break;
				}
				break;
			}
		}


		long long iMin = 21000000000; 
		for(list<long long>::iterator iter = li.begin(); iter != li.end(); iter++) {
			//아무것도 부딫히지 않았다면 1번도 돌지 않을것이며
			// 부딫히는게 있었다면 최소값을 찾아낸뒤
			if(*iter < iMin) iMin = *iter;
		}
		if(iMin != 21000000000)  {
			//iMin 이 변경이 이루어 진다면 
			iCount += iMin; // iCount에 이동거리의 최솟값을 대입
			printf("%lld\n", iCount); // 출력
			return 0;
		}
		///////////////////////
		///////////////////////
		///////////////////////
		///////////////////////
		///////////////////////
		///////////////////////
		//맵 한계 확인 ( 벽 부딫힘 확인 )
		///////////////////////
		///////////////////////
		///////////////////////
		///////////////////////
		///////////////////////
		///////////////////////
		///////////////////////
		if(X >= MapLimit) {
			iCount += iValue[i]-(X-MapLimit);
			printf("%lld\n", iCount);
			return 0;
		}
		if(X <= MapLimit*(-1)) {
			iCount += iValue[i]+(X+MapLimit);
			printf("%lld\n", iCount);
			return 0;
		}

		if(Y >= MapLimit) {
			iCount += iValue[i]-(Y-MapLimit);
			printf("%lld\n", iCount);
			return 0;
		}
		if(Y <= MapLimit*(-1)) {
			iCount += iValue[i]+(Y+MapLimit);
			printf("%lld\n", iCount);
			return 0;
		}
		///////////////////////
		///////////////////////
		///////////////////////
		///////////////////////

		iCount += iValue[i]; // 위 조건들의 그 어떠한 조건에도 걸리지 않았다는 말은 부딫히지 않은것이므로
		// 이동한 거리만큼 iCount 에 합산
		a.x[1] = X; // a의 x[1] y[1] 자리에 이동후의 거리를 대입후
		a.y[1] = Y;
		v.push_back(a); // v에 push_back을 해서 선분으로 만들어준다
		// 이미 a의 x[0] y[0]은 for문 시작할때 처음 x의 자리를 넣어줘서 시작점과 끝점을 a하나로 설명가능.
		if(cValue[i] == 'L'){ // L입력시
			iHandle++; // 핸들 +1 
			if(iHandle == 4) iHandle = 0;
		}else {
			iHandle--; // 아니면 -1
			if(iHandle == -1) iHandle = 3;
		}
		//iHandle 의 값에따라
				// 0 우
				// 1 상
				// 2 좌
				// 3 하
	}


	// for의 입력이 끝난뒤에는 그방향으로 계속 끝까지 이동을 해야하므로
	// 다시 위의 기초를 살짝 해준뒤
	a.x[0] = X;
	a.y[0] = Y;
	a.h = iHandle;

	
	X += XA[iHandle]*(MapLimit+1);
	Y += YA[iHandle]*(MapLimit+1);
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	//Vector 돌리기 Map에 그어진 선분들 하나하나 확인
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	// 0 우
	// 1 상
	// 2 좌
	// 3 하
	for(int j = 0; j < N+4; j++) {
		switch(v[j].h) {
		case 0:
			switch(iHandle) {
			case 0:
				if(Y == v[j].y[0])
				{
					if(v[j].x[0]-X <= 0 && a.x[0] < v[j].x[0])
					{
						li.push_back(v[j].x[0] -  a.x[0]);
					}
				}
				break;
			case 1:
				if(X >= v[j].x[0] && X <= v[j].x[1])
				{
					if(v[j].y[0] - Y <= 0 && a.y[0] < v[j].y[0])
					{
						li.push_back(v[j].y[0] - a.y[0]);
					}
				}
				break;
			case 2:
				if(Y == v[j].y[0])
				{
					if(v[j].x[1]-X >= 0 &&  a.x[0] > v[j].x[1])
					{
						li.push_back(a.x[0] - v[j].x[1]);
					}
				}
				break;
			case 3:
				if(X >= v[j].x[0] && X <= v[j].x[1])
				{
					if(v[j].y[0] - Y >= 0 && a.y[0] > v[j].y[0])
					{
						li.push_back(a.y[0] - v[j].y[0]);
					}
				}
				break;
			}
			break;
			// 0 우
			// 1 상
			// 2 좌
			// 3 하
		case 1:
			switch(iHandle) {
			case 0:
				if(Y >= v[j].y[0] && Y <= v[j].y[1])
				{
					if(v[j].x[0] - X <= 0 && a.x[0] < v[j].x[0])
					{
						li.push_back(v[j].x[0] - a.x[0]);
					}
				}
				break;
			case 1:
				if(X == v[j].x[0])
				{
					if(v[j].y[0]-Y <= 0  && a.y[0] < v[j].y[0])
					{
						li.push_back(v[j].y[0] - a.y[0]);
					}
				}
				break;
			case 2:
				if(Y >= v[j].y[0] && Y <= v[j].y[1])
				{
					if(v[j].x[1] - X >= 0 && a.x[0] > v[j].x[0])
					{
						li.push_back(a.x[0] - v[j].x[1]);
					}
				}
				break;
			case 3:
				if(X == v[j].x[0])
				{
					if(v[j].y[1]-Y >= 0 && a.y[0] > v[j].y[1])
					{
						li.push_back(a.y[0]-v[j].y[1]);
					}
				}
				break;
			}
			break;
			// 0 우
			// 1 상
			// 2 좌
			// 3 하
		case 2:
			switch(iHandle) {
			case 0:
				if(Y == v[j].y[0])
				{
					if(v[j].x[1]-X <= 0 && a.x[0] < v[j].x[1])
					{
						li.push_back(v[j].x[1] - a.x[0]);
					}
				}
				break;
			case 1:
				if(X >= v[j].x[1] && X <= v[j].x[0])
				{
					if(v[j].y[0] - Y <= 0 && a.y[0] < v[j].y[0])
					{
						li.push_back(v[j].y[0] - a.y[0]);
					}
				}
				break;
			case 2:
				if(Y == v[j].y[0])
				{
					if(v[j].x[0]-X >= 0 && a.x[0] > v[j].x[0])
					{
						li.push_back(a.x[0] - v[j].x[0]);
					}
				}
				break;
			case 3:
				if(X >= v[j].x[1] && X <= v[j].x[0])
				{
					if(v[j].y[0] - Y >= 0 && a.y[0] > v[j].y[0])
					{
						li.push_back(a.y[0] - v[j].y[0]);
					}
				}
				break;
			}
			break;
			// 0 우
			// 1 상
			// 2 좌
			// 3 하
		case 3:
			switch(iHandle) {
			case 0:
				if(Y >= v[j].y[1] && Y <= v[j].y[0])
				{
					if(v[j].x[0] - X <= 0 && a.x[0] < v[j].x[0])
					{
						li.push_back(v[j].x[0] - a.x[0]);
					}
				}
				break;
			case 1:
				if(X == v[j].x[0])
				{
					if(v[j].y[1]-Y <= 0 && a.y[0] < v[j].y[1])
					{
						li.push_back(v[j].y[0] - a.y[0]);
					}
				}
				break;
			case 2:
				if(Y >= v[j].y[1] && Y <= v[j].y[0])
				{
					if(v[j].x[1] - X >= 0 && a.x[0] > v[j].x[1])
					{
						li.push_back(a.x[0] - v[j].x[1]);
					}
				}
				break;
			case 3:
				if(X == v[j].x[0])
				{
					if(v[j].y[0]-Y >= 0 && a.y[0] > v[j].y[0])
					{
						li.push_back(a.y[0] - v[j].y[0]);
					}
				}
				break;
			}
			break;
		}
	}

	//
	///////////////////////
	///////////////////////
	//최소 확인
	///////////////////////
	///////////////////////
	///////////////////////
		long long iMin = 21000000000;
		for(list<long long>::iterator iter = li.begin(); iter != li.end(); iter++) {
			if(*iter < iMin) iMin = *iter;
		}
		if(iMin != 21000000000)  {
			iCount += iMin;
			printf("%lld\n", iCount);
			return 0;
		}
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	//맵 한계 확인
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	///////////////////////
	if(X >= MapLimit) {
		iCount += MapLimit - a.x[0];
		printf("%lld\n", iCount);
		return 0;
	}
	if(X <= MapLimit*(-1)) {
		iCount += a.x[0] - MapLimit*(-1);
		printf("%lld\n", iCount);
		return 0;
	}

	if(Y >= MapLimit) {
		iCount += MapLimit-a.y[0];
		printf("%lld\n", iCount);
		return 0;
	}
	if(Y <= MapLimit*(-1)) {
		iCount += a.y[0] - MapLimit*(-1);
		printf("%lld\n", iCount);
		return 0;
	}




}
댓글을 작성하려면 로그인해야 합니다.
문제

문제

출처

ICPC

10875번 뱀 문제 40% 틀렸습니다 뜹니다..ㅠ 주석있어요!

nuckly 6년 전 0

Baekjoon Online Judge

채점 현황

문제

유저 대회

고등학교 대회

출처

대학교 대회

도움말
