9-yuyu0830

[yuyu0830]

🔗 문제 링크

알고리즘 수업 - 버블 정렬 3

✔️ 소요된 시간

1시간

✨ 수도 코드

문제 이해

n의 길이를 가진 수열 a, b가 주어진다. a를 버블 정렬 하려고 할 때, 중간에 b와 같아지는 순간이 생기는지 생기지 않는지 여부를 1, 0으로 출력하자

• 5 ≤ n ≤ 10,000

문제 풀이

처음에는 이거 직접 버블 정렬 하면서 일일이 비교하면 시간이 말이 되나...? 싶었다. 버블 정렬은 무조건 n * (n - 1) / 2 번 연산할텐데? 싶어서 최대 경우의 수를 계산 해보니 약 5000만번... 여기에 매 정렬마다 10,000개씩 비교한다고 하면 무조건 시간 초과가 나겠다 싶었다.

일단 시간 초과가 나든 말든 한번 맨땅 헤딩부터 해보자는 마음으로 간단히 버블 정렬을 구현하고 매 번 배열을 처음부터 끝까지 비교하는 코드를 짰다.

bool same() {
    for (int i = 0; i < n; i++) 
        if (arr[0][i] != arr[1][i]) return false;
    return true;
}

while (rnd) {
    // sort [0] to [ptr - rnd]
    int a = arr[0][ptr];
    int b = arr[0][ptr + 1];

    arr[0][ptr] = min(a, b);
    arr[0][ptr + 1] = max(a, b);

    // if this index is last index in this round
    if (++ptr == rnd) {
        // next round
        ptr = 0;
        rnd--;
    }

    if (same()) {
        // if arr is same
        printf("1\n");
        return 0;
    }
}

돌려보니 이게 웬걸 중간까지 잘 가다가 시간 초과가 났다. 로직 자체는 문제가 없고 시간을 줄일 필요가 있는 케이스가 있다는 뜻이였다. 코드를 찬찬히 살펴보며 고민하던 중 아까 생각했던 "매번 처음부터 비교하면 너무 오래 걸릴 것 같은데" 라는 고민이 떠올랐고, 정렬되는 배열의 특징 상 앞부분이 같다면 그 앞부분은 정렬할 필요가 없다는 걸 깨달았다.

1. 만약 정렬 하는 도중 같아지는 경우의 수가 생긴다면 앞의 이미 같은 부분은 다시 비교할 필요가 없다.
2. 만약 같아지는 경우의 수가 없다고 해도 굳이 앞의 부분을 다시 비교할 필요가 없다. 어차피 중간부터 같아질 일이 없을테니까.

그래서 same() 함수만 조금 손봤다. 이렇게 하면 배열 비교를 정말 최악의 경우에도 5,000만(정렬 후 함수 호출) + 1만번(비교) 수행하게 된다!

bool same() {
    // start at 'arrPtr'
    for (int i = arrPtr; i < n; i++) {
        // if diff, terminate this function
        if (arr[0][i] != arr[1][i]) return false;
        // if same, then that index will same forever. no reason to compare again.
        arrPtr++;
    }
    return true;
}

📚 새롭게 알게된 내용

우연히 지나가다 본 문제라서 풀어봤는데 정렬 다시 공부 해야겠구나 느꼈다..

[InSange]

저는 버블정렬에서 큰 수 부터 처리하는 방식을 채택하였습니다.
큰 수는 저 뒤에 배치되기 때무넹
큰수의 위치가 B와 일치할 때까지 swap하는 식으로 하여 진행해줍니다.
그럼 각 수의 위치가 B의 위치에 맞게 조정하기 시작할 것이고 B의 값이 작거나 같을 경우 교체가 일어나지 않으므로 해당 위치 그대로 고정되게 됩니다.

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

using namespace std;

int N, n;
vector<int> A;
unordered_map<int, int> B;
priority_queue<int, vector<int>, less<int>> pq;

void Solve()
{
	cin >> N;
	N += 1;
	A.assign(N, 0);

	for (int i = 1; i < N; i++)
	{
		cin >> n;
		A[i] = n;
		pq.push(n);
	}

	for (int i = 1; i < N; i++)
	{
		cin >> n;
		B[n] = i;
	}

	bool flag = true;
	// 큰 값이 뒤로 먼저 정렬됨.
	// 변경되는 값은 
	while (flag && !pq.empty())
	{
		int cur = pq.top();
		pq.pop();

		int start = 1;
		while (A[start] != cur) start++;

		for (int i = start; i < B[cur]; i++)
		{
			swap(A[i], A[i + 1]);
		}
	}

	for (int i = 1; i < N; i++)
	{
		if (i != B[A[i]])
		{
			flag = false;
			break;
		}
	}

	cout << flag ? 1 : 0;
}

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

	Solve();

	return 0;
}

하지만 이렇게 풀었을 때 71%에서 막히더군요 어떤 테스트 케이스가 있을까요..? 몇시간째 고민하다가 다른 방식으로 풀었습니다.

다른 풀이

두 배열이 일치하는 검사 부분을 변경이 일어났을 때와 그 변경이 일어난 시점에서 A와 B가 일치할 경우 동일한 배열인지 검사해주는 방식으로 채택하였습니다.

[InSange]

swap을 쓰면 대소 관계만 비교해서 바로 처리할 수 있슴니다!

[seongwon030]

그냥 버블정렬로 하면 역시 시간초과가 나네요. 저는 swap하고 A와 B의 다음 원소가 같다면 또 비교해주는 식으로 해봤습니다. python으로는 시간초과가 여전히 발생해서 pypy로 하니까 통과되었습니다..

import sys
input = sys.stdin.readline

n = int(input())

A = list(map(int,input().split()))
B = list(map(int,input().split()))

def bubble_sort(A,B):
  for i in range(len(A) - 1, 0, -1):
      for j in range(i):
          if A[j] > A[j + 1]:
              A[j], A[j + 1] = A[j + 1], A[j]
              if A[j+1] == B[j+1]:
                if A==B:
                  print(1)
                  sys.exit(0)
  print(0)

if A==B:
  print(1)
  sys.exit(0)
else:
  bubble_sort(A,B)

[dhlee777]

버블정렬을 통해 처음부터끝까지 비교해주면 엄청난 시간복잡도가 발생하기에 두가지 조건을 걸어주어 경우의수를 잘라내주어야하는군요.. 버블정렬에 대해 찾아보며 개념도 잘 익혀갑니다..!