SHISENSHO문제를 푸는데 RTE오류가 발생하는데 이유를 모르겠습니다.

  • susul89
    susul89

    사천성 문제인데요...
    RTE (SIGSEGV: segmentation fault, probably incorrect memory access or stack overflow)\
    오류가 발상합니다. 비주얼스투디오로 컴파일 할때는
    오류없이 답이 잘 출력이 되는데요...
    어느부분이 문제인지 모르겠습니다.

    알고리즘이 길어서 조금 설명을 해 드리면
    문자가 있는 좌표값을 각각 받아서
    같은 문자가 있는 곳 까지 3번안에 가는 방법을 검색합니다
    '.'이아니거나 사천성 크기의 제일 끝으로 가게되면
    그 부딪힌 부분이 자신과 맞는 문자쌍인지 확인을 하고
    아니면 모든 경우의 수를 또 확인해 나갑니다.

    +한가지 질문을 더 드리자면
    너무 알고르짐이 길어지고, 단순하게 모든 경우의 수를
    확인하는 알고리즘이 되었는데 뭔가 찝찝하네요
    저의 접근방향이 잘못된 것인가요?

    #include <iostream>
    #include<string>
    #include <string.h>
    
    
    using namespace std;
    
    string Matrix[55];
    int Row, Col, z, TotalAnswer = 0;
    
    class Answer
    {
    public:
        char chr;
        int coll;
        int row;
    
    };
    
    bool AnswerCheck(Answer Start, Answer Target);
    
    int main()
    {
        int Count;
        cin >> Count;
        while (Count--)
        {
            Row = 0; Col = 0; z = 0; TotalAnswer = 0;
            //string Char[26];
            Answer RAnswer[2500];
            cin >> Col >> Row;
    
    
    
            for (int i = 0; i < Col; i++)
            {
                cin >> Matrix[i];
            }
            Col -= 1;
            Row -= 1;
    
    
            //공백이 아닌 문자를 가진걸 찾아 정의한 클래스안에 정보 저장
            for (int i = 1; i < Col ; i++)
            {
                for (int j = 1; j < Row ; j++)
                {
                    if (Matrix[i][j] != '.')
                    {
                        RAnswer[z].chr = Matrix[i][j];
                        RAnswer[z].coll = i;
                        RAnswer[z].row = j;
                        z++;
    
                    }
                }
            }
    
    
    
    
            //같은 문자쌍 확인
            for (int i = 0; i < z; i++)
            {
                for (int j = i + 1; j < z; j++)
                {
                    if (RAnswer[i].chr == RAnswer[j].chr)
                    {
                        //함수 호출
                        if (AnswerCheck(RAnswer[i], RAnswer[j]))
                        {
                            TotalAnswer += 1;
                            //cout << i << "=>" << j << endl;
                        }
                    }
                }
            }
            cout << TotalAnswer<<endl;
        }
    
    }
    
    bool AnswerCheck(Answer Start, Answer Target)
    {
        int SourceColl = Start.coll;
        int SourceRow = Start.row;
        int TempColl = Start.coll;
        int TempRow = Start.row;
    
    
        //왼쪽 체크
        if ((Start.row - 1 >= 0 && Matrix[Start.coll][Start.row - 1] == '.') || Start.row - 1 == Target.row && Start.coll == Target.coll)
        {
    
            if (Start.row - 1 == Target.row && Start.coll == Target.coll){
                return true;
            }
            //왼쪽이 0이되거나 벽이 막힐떄 까지 계속감 
            for (int i = Start.row; i > 0 && Matrix[Start.coll][Start.row - 1] == '.'; i--)
            {
                Start.row--;
            }
            //부딪힌게 같은 문자인가 같은 문자면 트루값을 리턴
            if (Start.coll == Target.coll&&Start.row - 1 == Target.row)
            {
                return true;
            }
    
    
            //한번꺾었다!!!@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
    
    
            TempColl = Start.coll;
            TempRow = Start.row;
    
            //아니면 위나 아래로다시 진행 , 먼저 위
            for (int i = Start.coll; i > 0 && Matrix[Start.coll - 1][Start.row] == '.' && i<Target.coll; i--)
            {
                Start.coll--;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll - 1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
    
    
            ////두번쨰 꺾어사 오른쪽 왼쪽  진행!!!
            //위로 올라온후 무언가에 부딪히고, 좌나 우로 진행, 좌먼저
            for (int i = Start.row; i > 0 && Matrix[Start.coll][Start.row - 1] == '.' && i>Target.row; i--)
            {
                Start.row--;
            }
            if (Start.coll == Target.coll&&Start.row - 1 == Target.row)
            {
                return true;
    
            }
    
    
    
    
            //그다음 우진행
            for (int i = Start.row; i <Row && Matrix[Start.coll][Start.row + 1] == '.' && i<Target.row; i++)
            {
                Start.row++;
            }
            if (Start.coll == Target.coll&&Start.row + 1 == Target.row)
            {
                return true;
    
            }
    
    
            //처음꺽고 위쪽으로 가는 경우 다 조사했고 아래쪽으로 가는 경우 다 조사하자!!!
    
            Start.coll = TempColl;
            Start.row = TempRow;
    
            //다음 아래
            for (int i = Start.coll; i < Col && Matrix[Start.coll + 1][Start.row] == '.' && i<Target.coll; i++)
            {
                Start.coll++;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll + 1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
    
            ///아래 내려와서 좌 우 진행  먼저 왼쪽!!!
            for (int i = Start.row; i > 0 && Matrix[Start.coll][Start.row - 1] == '.' && i>Target.row; i--)
            {
                Start.row--;
            }
            if (Start.coll == Target.coll&&Start.row - 1 == Target.row)
            {
                return true;
    
            }
    
    
            //그다음 우진행
            for (int i = Start.row; i <Row && Matrix[Start.coll][Start.row + 1] == '.' && i<Target.row; i++)
            {
                Start.row++;
            }
            if (Start.coll == Target.coll&&Start.row + 1 == Target.row)
            {
                return true;
    
            }
        }
        Start.row = SourceRow;
        Start.coll = SourceColl;
        //오른쪽 체크
        if ((Start.row + 1 <= Row && Matrix[Start.coll][Start.row + 1] == '.') || (Start.row + 1 == Target.row && Start.coll == Target.coll))
        {
            if (Start.row + 1 == Target.row && Start.coll == Target.coll)
                return true;
    
            //오른쪽으로 쭉가는 거 확인
            for (int i = Start.row; i <Row && Matrix[Start.coll][Start.row + 1] == '.'; i++)
            {
                Start.row++;
            }
            if (Start.coll == Target.coll&&Start.row + 1 == Target.row)
            {
                return true;
    
            }
    
            //값 저장하고
            TempColl = Start.coll;
            TempRow = Start.row;
            //위쪽 간후
            for (int i = Start.coll; i > 0 && Matrix[TempColl - 1][Start.row] == '.' && i>Target.coll; i--)
            {
                Start.coll--;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll-1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //좌
            for (int i = Start.row; i > 0 && Matrix[Start.coll][Start.row - 1] == '.' && i>Target.row; i--)
            {
                Start.row--;
            }
            if (Start.coll == Target.coll&&Start.row - 1 == Target.row)
            {
                return true;
    
            }
            //우
            for (int i = Start.row; i <Row && Matrix[Start.coll][Start.row + 1] == '.' && i<Target.row; i++)
            {
                Start.row++;
            }
            if (Start.coll == Target.coll&&Start.row + 1 == Target.row)
            {
                return true;
    
            }
            //저장한 값 불러온 후
            Start.coll = TempColl;
            Start.row = TempRow;
            //아래로
            for (int i = Start.coll; i < Col && Matrix[Start.coll + 1][Start.row] == '.' && i<Target.coll; i++)
            {
                Start.coll++;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll+1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //좌
            for (int i = Start.row; i > 0 && Matrix[Start.coll][Start.row - 1] == '.' && i>Target.row; i--)
            {
                Start.row--;
            }
            if (Start.coll == Target.coll&&Start.row - 1 == Target.row)
            {
                return true;
    
            }
            //우
            for (int i = Start.row; i <Row && Matrix[Start.coll][Start.row + 1] == '.' && i<Target.row; i++)
            {
                Start.row++;
            }
            if (Start.coll == Target.coll&&Start.row + 1 == Target.row)
            {
                return true;
    
            }
    
        }
        //처음값 불러오기
        Start.row = SourceRow;
        Start.coll = SourceColl;
        //위쪽 체크
        if ((Start.coll - 1 >= 0 && Matrix[Start.coll - 1][Start.row] == '.') || (Start.row == Target.row && Start.coll - 1 == Target.coll))
        {
            if (Start.row == Target.row && Start.coll - 1 == Target.coll)
                return true;
    
            //위쪽 끝까지 가고
            for (int i = Start.coll; i >0 && Matrix[Start.coll-1][Start.row] == '.' ; i--)
            {
                Start.coll--;
            }
            if (Start.coll-1 == Target.coll&&Start.row== Target.row)
            {
                return true;
    
            }
            //중간값 저장
            TempColl = Start.coll;
            TempRow = Start.row;
            //오른쪽 
            for (int i = Start.row; i <Row && Matrix[Start.coll][Start.row + 1] == '.' && i<Target.row; i++)
            {
                Start.row++;
            }
            if (Start.coll == Target.coll&&Start.row + 1 == Target.row)
            {
                return true;
    
            }
            //위
            for (int i = Start.coll; i > 0 && Matrix[TempColl - 1][Start.row] == '.' && i>Target.coll; i--)
            {
                Start.coll--;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll-1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //아래
            for (int i = Start.coll; i < Col && Matrix[Start.coll + 1][Start.row] == '.' && i<Target.coll; i++)
            {
                Start.coll++;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll+1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //중간값 불름
            Start.coll = TempColl;
            Start.row = TempRow;
            //왼쪽
            for (int i = Start.row; i > 0 && Matrix[Start.coll][Start.row - 1] == '.' && i>Target.row; i--)
            {
                Start.row--;
            }
            if (Start.coll == Target.coll&&Start.row - 1 == Target.row)
            {
                return true;
    
            }
            //위
            for (int i = Start.coll; i > 0 && Matrix[TempColl - 1][Start.row] == '.' && i>Target.coll; i--)
            {
                Start.coll--;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll-1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //아래
            for (int i = Start.coll; i < Col && Matrix[Start.coll + 1][Start.row] == '.' && i<Target.coll; i++)
            {
                Start.coll--;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll-1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
    
        }
        Start.row = SourceRow;
        Start.coll = SourceColl;
        //처음값 불러오기
        //아래쪽 체크
        if ((Start.coll +1 <= Col && Matrix[Start.coll + 1][Start.row] == '.') || (Start.row == Target.row && Start.coll + 1 == Target.coll))
        {
            if (Start.row == Target.row && Start.coll + 1 == Target.coll)
                return true;
    
            //아래
            for (int i = Start.coll; i < Col && Matrix[Start.coll + 1][Start.row] == '.' ; i++)
            {
                Start.coll++;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll+1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //중간값 저장
            TempColl = Start.coll;
            TempRow = Start.row;
            //왼
            for (int i = Start.row; i > 0 && Matrix[Start.coll][Start.row - 1] == '.' && i>Target.row; i--)
            {
                Start.row--;
            }
            if (Start.coll == Target.coll&&Start.row - 1 == Target.row)
            {
                return true;
    
            }
            //위
            for (int i = Start.coll; i > 0 && Matrix[TempColl - 1][Start.row] == '.' && i>Target.coll; i--)
            {
                Start.coll--;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll-1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //아래
            for (int i = Start.coll; i < Col && Matrix[Start.coll + 1][Start.row] == '.' && i<Target.coll; i++)
            {
                Start.coll++;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll+1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //중간값 불러오기
            Start.coll = TempColl;
            Start.row = TempRow;
            //오른쪽
            for (int i = Start.row; i <Row && Matrix[Start.coll][Start.row + 1] == '.' && i<Target.row; i++)
            {
                Start.row++;
            }
            if (Start.coll == Target.coll&&Start.row + 1 == Target.row)
            {
                return true;
    
            }
    
            for (int i = Start.coll; i > 0 && Matrix[TempColl - 1][Start.row] == '.' && i>Target.coll; i--)
            {
                Start.coll--;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll-1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
            //아래
            for (int i = Start.coll; i < Col && Matrix[Start.coll + 1][Start.row] == '.' && i<Target.coll; i++)
            {
                Start.coll++;
            }
            //부딪힌게 같은 A인가 확인, A이면
            if (Start.coll+1 == Target.coll&&Start.row == Target.row)
            {
                return true;
    
            }
        }
        return false;
    }
    

    문단을 구분하기 위해 앞과 뒤에 빈 줄 하나씩을 반드시 추가하셔야 합니다.


    마지막으로 자주_하는_실수_모음 페이지를 읽으시면서 혹시 해당되는 사항이 있진 않은지 생각해 보세요.

    위 내용이 지켜지지 않은 질문은 답변이 오래 걸릴 수 있습니다.

    아래 '편집하기' 버튼을 눌러 글을 쓰실 수 있습니다.


    9년 전
1개의 댓글이 있습니다.
  • JongMan
    JongMan

    SIGSEGV 오류는 대개 잘못된 메모리 접근으로 발생합니다. 많은 경우 배열 범위 밖의 값에 접근할 때 발생하죠. 코드가 이렇게 길고 복잡하면 이런 문제를 찾기 어려워집니다.

    더 간단하게 짜는 방법이 있으실 것 같네요. ^^; 2번 꺾는 모든 방법을 하드코딩하지 않고 짜는 방법을 생각해 보세요.


    9년 전 link
  • 정회원 권한이 있어야 커멘트를 다실 수 있습니다. 정회원이 되시려면 온라인 저지에서 5문제 이상을 푸시고, 가입 후 7일 이상이 지나셔야 합니다. 현재 문제를 푸셨습니다.