백준 알고리즘 1966

#include
using namespace std;
#define SWAP(x,y,z) z = x, x = y, y = z;

class documentary {
private:
	int priority;
	bool target;
public:

	documentary() {
		priority = 0;
		target = false;
	}

	documentary(int p, bool t) {
		priority = p;
		target = t;
	}

	void set_priority(int p) {
		priority = p;
	}

	int get_priority() {
		return priority;
	}

	void set_target(bool t) {
		target = t;
	}

	bool get_target() {
		return target;
	}

};

class queq {
private:
	documentary arr[100];
	documentary *_front;
	documentary *_back;
	int size;
	void bubble_swap() {
		documentary temp;
		for (int i = 0; i < size; i++) {
			SWAP(arr[i], arr[i + 1], temp);
		}
	}
	void renew() {
		if (size == 0) {
			_front = nullptr;
			_back = nullptr;
		}
		else {
			_back = arr + size - 1;
			_front = arr;
		}
	}
public:
	queq() {
	//	memset(arr, -1, 1000 * sizeof(int));
		size = 0;
		_front = nullptr;
		_back = nullptr;
	}
	void push(documentary a) {
		//		cout << "pushed " << a << endl;
		arr[size] = a;
		size++;
		renew();
	}
	documentary pop() {
		documentary temp, temp2;
		if (size != 0) {
			size--;
			temp = arr[0];
			arr[0] = temp2;
			renew();
			bubble_swap();
			return temp;
		}
		else {
			return temp2;
		}
	}
	int rsize() {
		return size;
	}
	int empty() {
		if (size == 0) {
			return 1;
		}
		else {
			return 0;
		}
	}
	documentary front() {
		documentary temp;
		if (_front == nullptr) {
			return temp;
		}
		return *_front;
	}
	documentary back() {
		documentary temp;
		if (_back == nullptr) {
			return temp;
		}
		return *_back;
	}
};


bool is_least(documentary darr[], int j, int t_p) {
	for (int i = 0; i < j; i++) {
		if (darr[i].get_priority() > t_p) {
			return false;
		}
	}
	return true;
}

void suc_doc_bubble_swap(documentary docarr[], int size) {
	for (int i = 0; i < size - 1; i++) {
		docarr[i] = docarr[i + 1];
	}
	
}
void fal_doc_bubble_swap(documentary docarr[], int size) {
	documentary temp;
	temp = docarr[0];
	for (int i = 0; i < size - 1; i++) {
		docarr[i] = docarr[i + 1];
	}
	docarr[size - 1] = temp;
}
int main() {
	int T;
	queq q;
	cin >> T;


	int N, M, P, print_cnt;
	for (int i = 0; i < T; i++) {
		documentary docarr[100];
		print_cnt = 0;
		cin >> N >> M;

		for (int j = 0; j < N; j++) {
			cin >> P;
			if (j == M) {
				docarr[j].set_target(true);
			}
			docarr[j].set_priority(P);
		}

		while(print_cnt != N){
			if (is_least(docarr, N - print_cnt, docarr[0].get_priority())) {
				q.push(docarr[0]);
				suc_doc_bubble_swap(docarr, N - print_cnt);
				print_cnt++;
			}
			else {
				fal_doc_bubble_swap(docarr, N - print_cnt);
			}
		}
		for (int j = 0; j < N; j++) {
			if (q.pop().get_target()) {
				cout << j + 1 << endl;
			}
		}


	}

//	while (1);

	return 0;
}

https://www.acmicpc.net/problem/1966

우선순위 Int타입 변수 Priority,

찾고있는 문서대상 Bool타입 변수 Target

를 가지는 documentary클래스를 이용한다.

우선순위가 중복되지않는 경우는 단순히 오름차순의 순서로 정리되지만

우선순위가 중복되는 경우 문서의 움직임을 객체로서 조작할 수 있도록

documentary 배열을 컨테이너로 사용한다.

suc_doc_bubble_swap은 print가 success했을 경우 배열의 0번째 인덱스를 큐 안에 넣고

컨테이너에서 제거.

fal_doc_bubble_swap은 print가 fail했을 경우 배열의 0번째 인덱스를 가장 마지막인덱스로 옮겨주고

인덱스를 하나씩 밀어준다.

완성된 q객체를 하나하나 pop해주면서 get_target이 true를 정확히 리턴하면 끝.