21-Insange

[InSange]

🔗 문제 링크

Find Valid Matrix Given Row and Column Sums

✔️ 소요된 시간

8시간

✨ 수도 코드

문제 설명

입력값으로 각 행의 요소들을 더한 값과 각 열의 요소들을 더한 값이 주어진다.
Input: rowSum = [3,8], colSum = [4,7]
rowSum[0] 번째 행의 요소들을 모두 더한 값은 3이 되고
colSum[0] 번째 열의 요소들을 모두 더한 값은 4가 된다.

와 같이 구성이 되어야 한다.

첫 번째 접근 방식

행 인덱스 rIndex와 열 인덱스 cIndex가 0부터 시작해서 ans 행렬에 해당하는 부분 ans[rindex][cindex]가 위치하는 부분의 값 중 최소 값을 넣으면서 하면 되지 않을까였다.

최소값을 배치한 만큼 rowSum과 colSum에서 빼서 행과 열의 인덱스를 점차 증가시키는 방식으로 접근하였으나 런타임 에러가 발생하였다.

에러는 힙 버퍼 오버플로우로 최소값을 구할 때 인덱스가 rowSum과 colSum을 벗어나는 상황이 발생한 것이었다.

여기서 문득든 생각은 우리가 만드는 행렬은 모든 수를 써서 행과 열들의 합들을 일치시켜줘야하는게 아닌가? 였고 예외사항들을 찾다보니 시간이 오래걸리게 되었다.

풀이 방식

rowSum과 colSum을 다 탐색하되 배열에 값이 남을 경우 다 채워주는 방식으로 가기로하였다.

1. 해당 행과 열 인덱스 rIndex, cIndex의 값들을 통해 최소값을 파악하고 업데이트한다.
2. rowSum과 colSum에서 0이 발생하면 해당하는 인덱스의 값을 증가시켜준다.
3. 만약 인덱스의 값이 배열의 크기보다 크거나 같을 경우 나머지 배열을 실행시켜준다.

class Solution {
public:
    vector<vector<int>> restoreMatrix(vector<int>& rowSum, vector<int>& colSum) {
        vector<vector<int>> ans;
        int rsize = rowSum.size();
        int csize = colSum.size();
        int rindex = 0;
        int cindex = 0;
        
        ans.assign(rsize, vector<int>(csize, 0));
        
        while(rindex < rsize || cindex < csize)
        {
            if(rindex >= rsize)
            {
                ans[rindex-1][cindex] = colSum[cindex];
                cindex++;
                continue;
            }
            else if(cindex >= csize)
            {
                ans[rindex][cindex-1] = rowSum[rindex];
                rindex++;
                continue;
            }
            
            int val = min(colSum[cindex], rowSum[rindex]);
            
            ans[rindex][cindex] = val;
            rowSum[rindex] -= val;
            colSum[cindex] -= val;
            
            if(!rowSum[rindex])
            {
                rindex++;
            }
            if(!colSum[cindex])
            {
                cindex++;
            }
        }
        
        return ans;
    }
};

두번째 풀이

문제에서는 요구 사항을 충족하는 2D 배열을 반환한다고 되어있다.
즉, rowSum의 요소들의 모든 합과 colSum의 요소들의 모든 합이 같아야 요구 사항을 충족하는 배열이 반환이 된다.

그럼 결국 위의 알고리즘을 진행하다보면 맨 마지막으로 비교하는 값들은 서로 같은 값이 되며 추가적인 연산이 필요없어지게 된다.

class Solution {
public:
    vector<vector<int>> restoreMatrix(vector<int>& rowSum, vector<int>& colSum) {
        int numRows = rowSum.size();
        int numCols = colSum.size();
        vector<vector<int>> result(numRows, vector<int>(numCols, 0));

        int i = 0, j = 0;

        while (i < numRows && j < numCols) {
            int val = min(rowSum[i], colSum[j]);
            result[i][j] = val;
            rowSum[i] -= val;
            colSum[j] -= val;

            if (rowSum[i] == 0) {
                i++;
            }
            if (colSum[j] == 0) {
                j++;
            }
        }
        return result;
    }
};

📚 새롭게 알게된 내용

[yuyu0830]

신기하네요.. 각 값을 0으로 만들면서 내려가는게 가우스 조던 소거법 생각도 나는데 어떻게 이런 풀이를 떠올렸는지 신기하네요

이렇게 풀면 오류가 날 수도 있지 않나..? 싶었는데 어차피 음수 값도 없고 항상 가능한 경우의 수만 주어지니 마지막에는 무조건 0이 될 수 밖에 없게 남겠네요.. 풀이도 풀이고 코드도 간결하고 이해하기 쉬워서 좋았습니다 ㅎㅎ

[seongwon030]

row와 col의 sum에서 계속 차감하면서 표를 갱신해주는 방법이 참신했습니다. 그렇게 하면 표 크기가 커져도 작은 표부터 확정지어 나갈 수 있어서 확실히 좋은 해결법인 것 같아요! 풀이 잘 봤습니당