12-InSange

[InSange]

🔗 문제 링크

전깃줄

✔️ 소요된 시간

하루

✨ 수도 코드

첫 번째 풀이

1. i번째 전깃줄이 i+1번부터 N번째 줄까지 비교를 하였을 때 겹칠경우(CrossCheck함수가 true) cross2차원 배열에다가 i번째 요소에 겹치는 인덱스 값을 넣어준다.
2. i번째와 겹치는 전깃줄의 개수와 해당 인덱스 번호 i를 내림차순 우선순위 큐에 넣어준다. pair<겹치는 전깃줄의 개수, 인덱스 번호
3. 우선순위큐에서 하나씩 꺼내서 해당 인덱스의 전깃줄을 삭제해준다. 삭제 확인 배열로 live 불형 배열을 선언해주었다.
4. 삭제하기 전에 만약 겹치는 줄이 이미 삭제된 상태라면 무시하고 다음 겹친 줄을 확인해주는 식으로 진행한다.

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int N, a, b, answer;
vector<pair<int, int>> line;
vector <vector<int>> cross; // 해당 index에서 교차하는 선의 개수
vector<bool> live;
priority_queue<pair<int, int>> pq;

bool CrossCheck(pair<int, int>& l1, pair<int, int>& l2)
{
	if (l1.first < l2.first && l1.second > l2.second) return true;
	if (l1.first > l2.first && l1.second < l2.second) return true;
	return false;
}

void Solve()
{
	live.assign(501, true);
	cross.assign(501, vector<int>());
	answer = 0;

	cin >> N;

	for (int i = 0; i < N; i++)
	{
		cin >> a >> b;
		line.push_back({ a, b });
	}

	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < N; j++)
		{
			if (CrossCheck(line[i], line[j]))
			{
				cross[line[i].first].push_back(line[j].first);
			}
		}
		pq.push({ cross[line[i].first].size(), line[i].first});
	}

	while (!pq.empty())
	{
		pair<int, int> cur = pq.top();
		pq.pop();

		//cout << cur.first << ", " << cur.second << "\n";

		if (cur.first == 0) break;
		bool flag = false;

		for (const int& val : cross[cur.second])
		{
			if (live[val] == false) continue;
			flag = true;
			break;
		}

		if (flag)
		{
			answer++;
			live[cur.second] = false;
		}
	}

	cout << answer;
}

int main()
{
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	Solve();

	return 0;
}

결과는?

놀랍게도 질문 게시판을 포함한 모든 테스트 케이스는 통과가 되었었다.
그러나.. 제출만하면 틀리는 것을 보아 필시 예외 조건이 있을 터인데 그것을 찾지 못했다..
결국 블로그 호출

두 번째 풀이

겹치는 전깃줄 = 전체 전깃줄 - 안 겹치는 전깃줄 이다!!
위의 풀이식은 상상도 못했다.

1. 전깃줄은 line' 배열에 저장되며 first는 시작지점, second`는 도착지점이다.
2. first 시작지점을 기준으로 sort함수를 통해 정렬해준다.
3. 모든 전깃줄은 자기 자신을 포함해 dp에 1로 시작한다.
4. 이후 i보다 작은 전깃줄들과 비교해서 second의 값이 현재의 전깃줄보다 작을 경우 겹치게 된다. i의 first는 내림 차순이기에 j의 first보다 크다! 그러니 second의 값이 j보다 작으면 전깃줄은 교차하게 된다.
5. 그렇게 안겹치는 전깃줄을 발견하게 되면 dp[j] 번째 줄은 i와 겹치지 않기때문에 1을 더해준 값에서 dp[i]와 비교해서 dp[i]의 값을 업데이트 시켜준다. j는 i보다 작기 때문에 j가 안겹치는 값들은 i에서도 안겹쳐지기 때문이다.
6. 그렇게 최신화 된 dp[i]의 값과 answer중 큰 값을 가져온다. 우리는 최소 전깃줄을 찾아줘야 하기 때문에 전체 전깃줄에서 빼려면 가장 큰 max값을 찾아줘야 한다.

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int N, a, b, answer;
vector<pair<int, int>> line;
vector<int> dp;

void Solve()
{
	cin >> N;

	answer = 0;
	dp.assign(N + 1, 1);

	for (int i = 0; i < N; i++)
	{
		cin >> a >> b;
		line.push_back({ a, b });
	}

	sort(line.begin(), line.end());

	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < i; j++)
		{
			//cout << line[i].first << ", " << line[j].first << "일 때\n";
			if (line[j].second < line[i].second) {
				dp[i] = max(dp[i], dp[j] + 1);
				//cout << line[i].first << "-> i 의 dp 값 : " << dp[i] << "\n";
				//cout << line[j].first << "-> j 의 dp 값 : " << dp[j] << "\n";
			}
		}

		answer = max(answer, dp[i]);
	}

	cout << N - answer;
}

int main()
{
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	Solve();

	return 0;
}

후기

문제를 풀면서 이게 골드 5라고 무수히 많은 생각이 들었다..
실제로 풀이 방식을 떠나 모든 테스트 케이스를 통과했음에도 틀렸다고 뜨기에 예외를 찾는데 시간이 매우 오래 걸렸던 문제이다.
이러한 접근 방식은 많은 문제를 겪어 봐야 늘 것 같았다.

📚 새롭게 알게된 내용

참고 블로그

[yuyu0830]

first 값 기준으로 정렬한 뒤 second 값으로 겹치는지 안겹치는지 여부를 계산하고 그 값을 1차원 DP 로 연산하는군요.. 이렇게도 가능하네요..
전 단순하게 2차원 DP로 계산 했습니다! dp[x][y]는 x, y 값보다 작은 전깃줄들의 개수가 되고 그걸 하나씩 갱신해나가는 식으로 풀었습니다!
특히 겹치는 경우를 연산하기가 어려워 pair<pair<bool, bool>, int> 로 dp 배열을 선언해 풀었습니다!

#include <iostream>

#define MP(a, b, x) make_pair(make_pair(a, b), x)
#define VALUE(x) x.second
#define GET_X(x) x.first.first
#define GET_Y(x) x.first.second

using namespace std;

typedef pair<pair<bool, bool>, int> bbi;

int arr[510][510] = {0, };
bbi dp[510][510];

int main() {
    int n, mx = 0, my = 0; cin >> n;
    for (int i = 0; i < n; i++) {
        int x, y; cin >> x >> y;

        mx = x > mx ? x : mx;
        my = y > my ? y : my;

        arr[x][y] = 1;
    }
    
    for (int i = 1; i <= mx; i++) {
        for (int j = 1; j <= my; j++) {
            if (i == 1) 
                dp[1][j] = MP(false, arr[1][j], arr[1][j]);

            else if (j == 1) 
                dp[i][1] = MP(arr[i][1], false, arr[i][1]);
            
            else
                dp[i][j] = MP(false, false, 0);
        }
    }

    int sum;

    for (sum = 2; sum <= (my + mx + 1); sum++) {
        int j = max(sum - mx, 1);

        while (sum - j >= 1) {
            int x = sum - j;
            int y = j++; 

            if (y > my) break;

            bbi tx = dp[x][y - 1];
            bbi ty = dp[x - 1][y];

            if (!arr[x][y] || (GET_X(tx) || GET_Y(ty))) {
                dp[x][y] = MP(GET_X(tx), GET_Y(ty), max(VALUE(tx), VALUE(ty)));
                continue;
            }

            dp[x][y] = MP(1, 1, max(VALUE(tx), VALUE(ty)) + 1);
        }
    }

    printf("%d\n", n - VALUE(dp[mx][my]));
}

[seongwon030]

저도 처음에 A에 대해 오름차순해서 교차하는 전깃줄을 찾았는데 교차하는 걸 찾는다는게 쉽지 않았어요. 고민해보다가 다른 풀이를 참고했습니다. A에 대해 오름차순 정렬해서 B에서 교차하지 않는 경우를 dp로 계속 갱신하면 되더군요. 결국 찾아야 될 것은 교차하지 않게 없앨 전깃줄의 최소이므로 dp의 최대를 전체에서 빼면 최소 전깃줄이 나온다는게 신기했습니다.

n = int(input())
k = []
dp = [1]*n

for i in range(n):
  a,b = map(int,input().split())
  k.append([a,b])

k.sort()

for i in range(1,n):
  for j in range(0,i):
    if k[i][1] >= k[j][1]: 
      dp[i] = max(dp[i],dp[j]+1)
print(n-max(dp))

[InSange]

first 값 기준으로 정렬한 뒤 second 값으로 겹치는지 안겹치는지 여부를 계산하고 그 값을 1차원 DP 로 연산하는군요.. 이렇게도 가능하네요.. 전 단순하게 2차원 DP로 계산 했습니다! dp[x][y]는 x, y 값보다 작은 전깃줄들의 개수가 되고 그걸 하나씩 갱신해나가는 식으로 풀었습니다! 특히 겹치는 경우를 연산하기가 어려워 pair<pair<bool, bool>, int> 로 dp 배열을 선언해 풀었습니다!

#include <iostream>

#define MP(a, b, x) make_pair(make_pair(a, b), x)
#define VALUE(x) x.second
#define GET_X(x) x.first.first
#define GET_Y(x) x.first.second

using namespace std;

typedef pair<pair<bool, bool>, int> bbi;

int arr[510][510] = {0, };
bbi dp[510][510];

int main() {
    int n, mx = 0, my = 0; cin >> n;
    for (int i = 0; i < n; i++) {
        int x, y; cin >> x >> y;

        mx = x > mx ? x : mx;
        my = y > my ? y : my;

        arr[x][y] = 1;
    }
    
    for (int i = 1; i <= mx; i++) {
        for (int j = 1; j <= my; j++) {
            if (i == 1) 
                dp[1][j] = MP(false, arr[1][j], arr[1][j]);

            else if (j == 1) 
                dp[i][1] = MP(arr[i][1], false, arr[i][1]);
            
            else
                dp[i][j] = MP(false, false, 0);
        }
    }

    int sum;

    for (sum = 2; sum <= (my + mx + 1); sum++) {
        int j = max(sum - mx, 1);

        while (sum - j >= 1) {
            int x = sum - j;
            int y = j++; 

            if (y > my) break;

            bbi tx = dp[x][y - 1];
            bbi ty = dp[x - 1][y];

            if (!arr[x][y] || (GET_X(tx) || GET_Y(ty))) {
                dp[x][y] = MP(GET_X(tx), GET_Y(ty), max(VALUE(tx), VALUE(ty)));
                continue;
            }

            dp[x][y] = MP(1, 1, max(VALUE(tx), VALUE(ty)) + 1);
        }
    }

    printf("%d\n", n - VALUE(dp[mx][my]));
}

결국 DP로 해내셨네요 ㅋㅋㅋ

[dhlee777]

얼마전에 가장긴 증가하는 부분순열 문제를 풀었는데 이 문제의 알고리즘이 보여서 놀랐습니다...시작점을 기준으로 정렬한후 끝점만을 이제 고려하여 가장 긴 증가수열을 찾아서 제거해야하는전깃줄수=전체전깃줄수-가장긴증가수열 이 되는 것이군요..! 항상 깔끔한 코드를 보며 많이 배우고있습니다 !