728x90

조합

조합은 n개의 숫자에서 r개를 뽑는 경우의 수를 뜻한다. 조합과 비교되는 순열은 n개의 숫자 중 r개를 뽑아 순서를 고려해 나열할 경우의 수를 이야기한다. 순열과 조합의 차이는 순서의 고려 유무이다. 조합은 실제 알고리즘 코딩 테스트에서 순열보다 조합의 출제 빈도수가 높고, 응용할 문제도 많다. 조합은 동적 계획법의 시작이라고 볼 수 있다. 따라서 알고리즘에서 조합을 구현할 때는 수학 공식을 코드화하지 않고 점화식을 사용해 표현한다.

 

조합의 점화식

1. 특정 문제를 가정하기

   5개 데이터에서 3개를 선택하는 조합의 경우의 수를 푸는 문제로 가정

2. 모든 부분 문제가 해결된 상황이라고 가정하고 지금 문제 생각하기

   먼저 5개의 데이터 중 4개를 이미 선택이 완료된 데이터라고 가정한다. 그리고 마지막 데이터의 선택 여부에 따른 경우의 수를 계산한다. 만약 마지막 데이터를 포함해 총 3개의 데이터를 선택하려면 선택이 완료됐다고 가정한 4개의 데이터에서 2개를 선택해야 된다. 마지막 데이터를 포함하지 않고 총 3개의 데이터를 선택하려면 이전 데이터 4개 중 3개를 선택해야 한다. 2가지 경우의 수를 합치면 데이터 5개 중 3개를 선택하는 경우의 수가 나온다.

 

5개 중 3개를 선택하는 경우의 수 점화식

D[5][3] = D[4][2] + D[4][3]

조합 점화식

D[i][j] = D[i - 1][j] + D[i - 1][j - 1]

점화식이 간단하므로 외울 수도 있지만, 원리를 정확하게 이해하는 것이 문제 응용하기 유리하다.

728x90

'알고리즘 > 알고리즘 이론' 카테고리의 다른 글

최소 신장 트리  (0) 2022.06.23
플로이드-위셜  (0) 2022.06.23
벨만 - 포드  (0) 2022.06.21
다익스트라  (0) 2022.06.21
위상 정렬  (0) 2022.06.21
728x90

최소 신장 트리

최소 신장 트리란 그래프에서 모든 노드를 연결할 때 사용된 에지들의 가중치의 합을 최소로 하는 트리이다.

 

최소 신장 트리의 특징

  • 사이클이 포함되면 가중치의 합이 최소가 될 수 없으므로 사이클을 포함하지 않는다.
  • N개의 노드가 있으면 최소 신장 트리를 구성하는 에지의 수는 항상 N - 1개다.

최소 신장 트리 핵심 이론

1. 에지 리스트로 그래프를 구현하고 유니온 파인드 배열 초기화하기

   최소 신장 트리는 데이터를 노드가 아닌 에지 중심으로 저장하므로 인접 리스트가 아닌 에지 리스트의 형태로 저장한다. edge class는 일반적으로 노드 변수 2개와 가중치 변수로 구성된다. 사이클 처리를 위한 유니온 파인드 배열도 함께 초기화한다. 배열의 인덱스를 해당 자리의 값으로 초기화하면 된다.

 

2. 그래프 데이터를 가중치 기준으로 정렬하기

   에지 리스트의 담긴 그래프를 데이터를 가중치 기준으로 오름차순 정렬한다.

 

3. 가중치가 낮은 에지부터 연결 시도하기

   가중치가 낮은 에지부터 순서대로 선택해 연결을 시도한다. 이때 바로 연결하지 않고 이 에지를 연결했을 때 그래프에 사이클 형성 유무를 find연산을 이용해 확인한 후 사이클이 형성되지 않을 때만 union연산을 이용해 두 노드를 연결한다.

 

4. 과정 3 반복하기

   전체 노드의 개수가 N개이면 연결한 에지의 개수가 N - 1이 될 때까지 과정 3을 반복한다.

 

5. 총 에지 비용 출력하기

   에지의 개수가 N - 1이 되면 알고리즘을 종료하고, 완성된 최소 신장 트리의 총 에지 비용을 출력한다. 최소 신장 트리는 다른 그래프 알고리즘과 달리, 에지 리스트의 형태를 이용해 데이터를 담는다는 특징이 있다. 그 이유는 에지를 기준으로 하는 알고리즘이기 때문이다. 또한 사이클이 존재하면 안 되는 특징을 지니고 있기 때문에 사이클 판별 알고리즘인 유니온 파인드 알고리즘을 내부에 구현해야 된다.

 

코드로 표현

static int[] parent;
static PriorityQueue<pEdge> que;

노드 수, 에지 수 입력
que = new PriorityQueue<>();  // 자동 정렬을 위해 우선순위 큐 자료구조 선택하기

parent = new int[n + 1];
parent배열 인덱스로 초기화

for(int i = 0; i < M; i++) {
	시작 노드 s, 끝 노드 e, 가중치 입력받기 v
    que.add(new pEdge(s,e, v));
}
int useEdge = 0;
int result = 0;
while(useEdge < N - 1) {
	pEdge now = que.poll();
    if(find(now.s) != find(now.e)) {  // 같은 부모가 아니라면 연결해도 사이클이 생기지 않음
    	union(now.s, now.e);
        result = result + now.v;
        useEdge++;
    }
}
Union 연산 : 대표 노드끼리 연결하기
a = find(a);
b = find(b);
if(a != b) {
	parent[b] = a;
}
Find 연산
if(a == parent[a]) {
	return a;
}
else {
	return parent[a] = find(parent[a]); // 경로압축
}

class pEdge implements Comparable<pEdge> {
	int s;
    int e;
    int v;
    pEdge(int s, int e, int v) {
    	this.s = s;
        this.e = e;
        this.v = v;
    }
    @Override
    public int compareTo(pEdge o) {
    	// 가중치를 기준으로 오름차순 정렬을 하기 위해 compareTo 재정의하기
    	return this.v - o.v;
    }
}

 

728x90

'알고리즘 > 알고리즘 이론' 카테고리의 다른 글

조합  (0) 2022.06.28
플로이드-위셜  (0) 2022.06.23
벨만 - 포드  (0) 2022.06.21
다익스트라  (0) 2022.06.21
위상 정렬  (0) 2022.06.21
728x90

플로이드-위셜

그래프에서 최단 거리를 구하는 알고리즘으로, 주요 특징은 음수 가중치가 있어도 수행할 수 있고, 동적 계획법의 원리를 이용해 알고리즘에 접근한다.

 

시간 복잡도(노드수 : V)

O(V^3)

 

플로이드-위셜 핵심 이론

플로이드-위셜 알고리즘을 도출하는 가장 핵심적인 원리는 A 노드에서 B 노드까지 최단 경로를 구했다고 가정했을 때 최단 경로 위에 K 노드가 존재한다면 그것을 이루는 부분 경로 역시 최단 경로라는 것이다.

 

플로이드 위셜 점화식

D[S][E] = Math.min(D[S][E], D[S][K] + D[K][E])

 

1. 배열을 선언하고 초기화하기

D[S][E]는 노드 S에서 노드 E까지의 최단 거리를 저장하는 배열이라 정의한다. S와 E의 값이 같은 같은 0, 다른 칸은 무한으로 초기화한다. 여기에서 S==E 는 자기 자신에게 가는 데 걸리는 최단 경로값을 의미하기 때문이다.

 

2. 최단 거리 배열에 그래프 데이터 저장하기

출발 노드는 S, 도착 노드는 E, 이 에지의 가중치는 W라고 했을 때 D[S][E] = W로 에지의 정보를 배열에 입력한다. 이로써 플로이드-위셜 알고리즘은 그래프를 인접 행렬로 표현한다는 것을 알 수 있다.

 

3. 점화식으로 배열 업데이트하기

기존에 구했던 점화식을 3중 for문 형태로 반복하면서 배열의 값을 업데이트한다.

 

플로이드-위셜 알고리즘 로직

for 경유지 K에 관해 (1 ~ N)

   for 출발 노드 S에 관해 (1 ~ N)

      for 도착 노드 E에 관해 (1 ~ N)

        D[S][E] = Math.min(D[S][E], D[S][K] + D[K][E]) 

 

플로이드-위셜 알고리즘은 모든 노드 간의 최단 거리를 확인해 주기 때문에 시간 복잡도가 빠르지 않은 편이다. 플로이드-위셜 알고리즘을 사용해야 하는 문제가 나오면 일반적으로 노드의 개수의 범위가 다른 그래프에 적게 나타난다는 것을 알 수 있다.

 

코드로 표현

static int N,M;
static int distance[][];

distance = new int[n + 1][n + 1];

for(int i = 1; i <= N; i++) { // 인접 행렬 초기화
	for(int j = 1; j <= N; j++) {
    	if(i == j) {
        	distance[i][j] = 0;
        }
        else {
        	distance[i][j] = 1000001; // 충분히 큰 수로 저장
        }
    }
}
for(int i = 0; i < M; i++) {
	int s, e, v 입력받기
    if(distance[s][e] > v) {
    	distance[s][e] = v;
    }
}
for(int k = 1; k <= N; k++) { // 플로이드-위셜 알고리즘 수행하기
	for(int i = 1; i <= N; i++) {
    	for(int j = 1; j <= N; j++) {
        	if(distance[i][j] > distance[i][k] + distance[k][j])
            	distance[i][j] = distance[i][k] + distance[k][j];
            }
        }
    }
}
출력 부분

 

728x90

'알고리즘 > 알고리즘 이론' 카테고리의 다른 글

조합  (0) 2022.06.28
최소 신장 트리  (0) 2022.06.23
벨만 - 포드  (0) 2022.06.21
다익스트라  (0) 2022.06.21
위상 정렬  (0) 2022.06.21
728x90

벨만-포드

벨만-포드 알고리즘은 그래프에서 최단 거리를 구하는 알고리즘으로, 특정 출발 노드에서 다른 모든 노드까지의 최단 경로를 탐색한다. 음수 가중치 에지가 있어도 수행할 수 있다. 또한 전체 그래프에서 음수 사이클의 존재 여부를 판단할 수 있다.

 

시간 복잡도(노드 수 : V, 에지 수 : E)

O(VE)

 

벨만-포드 알고리즘 핵심 이론

1. 에지 리스트로 그래프 구현하고 최단 경로 배열 초기화하기

   벨만-포드 알고리즘은 에지를 중심으로 동작하므로 그래프를 에지 리스트로 구현한다. 또한 최단 경로 배열은 출발 노드는 0, 나머지 노드는 무한대로 초기화한다. 

2. 모든 에지를 확인해 정답 배열 업데이트하기

   최단 거리 배열에서 업데이트 반복 횟수는 노드 개수 -1입니다. 노드 개수가 N이고, 음수 사이클이 없을 때 특정 노드 두 노드의 최단 거리를 구성할 수 있는 에지의 최대 개수는 N-1이기 때문이다. 특정 에지 E = (s, e, w)에서 다음 조건을 만족하면 업데이트를 실행한다.

3. 음수 사이클 유무 확인하기

   음수 사이클 유무를 확인하기 위해 모든 에지를 한 번씩 다시 사용해 업데이트되는 노드가 발생하는지 확인한다. 만약 업데이트되는 노드가 있다면 음수 사이클이 있다는 뜻이 되고, 2단계에서 도출한 정답 배열이 무의미하고 최단 거리를 찾을 수 없는 그래프라는 뜻이 된다. 음수 사이클이 존재하면 이 사이클을 무한하게 돌수록 가중치가 계속 감소하므로 최단 거리를 구할 수 없다.

 

실제 코딩테스트에서는 벨만-포드 알고리즘을 사용해 최단 거리를 구하는 문제보다 음수 사이클을 판별하는 문제가 더 빈번하게 출제된다. 따라서 마지막에 한 번 더 모든 에지를 사용해 업데이트되는 노드가 존재하는지 확인해야 한다.

 

업데이트 조건과 방법

D[s] != 무한이며 D[e] > D[s] + w 일 때 D[e] = D[s] + w로 배열의 값을 업데이트한다.

음수 사이클이 없을 때 N - 1번 에지 사용 횟수를 반복하면 출발 노드와 모든 노드 간의 최단거리를 알려주는 정답 배열이 완성된다. 이렇게 완성 후 마지막으로 이 그래프에 음수 사이클이 존재하는지 확인해야 한다.

 

코드로 표현

Arrays.fill(distance, Integer.MAX_VALUE); // 최단 거리 배열 초기화하기
for(int i = 0; i < m; i++) {  // 에지 리스트에 데이터 저장하기
	edges[i] = new Edge(start, end, time);
}
// 벨만-포드 알고리즘 수행하기
distacne[1] = 0;
for(int i = 1; i < n; i++) {    // N보다 1개 적은 수만큼 반복하기
	for(int j = 0; j < m; j++) {
    	Edge edge = edges[j];
        // 더 작은 최단 거리가 있을 때 업데이트 하기
        if(distance[edge.start] != Integer.MAX_VALUE
        && distance[edge.end] > distance[edge.start] + edge.time) {
        	distance[edge.end] = distance[edge.start] + edge.time;
         }
    }
}
boolean mCycle = false;
for(int i = 0; i < m; i++) {   // 음수 사이클 확인하기
	Edge edge = edges[i];
    if(distance[edge.start] != Integer.MAX_VALUE
    && distance[edge.end] > distance[edge.start] + edge.time) {
    	mCycle = true;
    }
}
if(!mCycle) {  // 음의 사이클이 없을 때
	for(int i = 2; i <= n; i++) {
    	if(distance[i] == Integer.MAX_VALUE) {
        	System.out.println("-1");
        }
        else {
        	System.out.println(distance[i]);
        }
    }
}
else {   // 음의 사이클이 있을 때 
	System.out.println("-1");
}

class Edge {               // 에지 리스트를 편하게 다루기 위해 클래스로 별도 구현하기
	int start, end, time;  // 시작점, 도착점, 걸리는 시간
    public Edge(int start, int end, int time) {
    	this.start = start;
        this.end = end;
        this.time = time;
    }
}
728x90

'알고리즘 > 알고리즘 이론' 카테고리의 다른 글

최소 신장 트리  (0) 2022.06.23
플로이드-위셜  (0) 2022.06.23
다익스트라  (0) 2022.06.21
위상 정렬  (0) 2022.06.21
유니온 파인드  (0) 2022.06.21
728x90

다익스트라

다익스트라 알고리즘은 그래프에서 최단 거리를 구하는 알고리즘으로, 에지는 모두 양수 이어야 한다. 특정 노드에서 다른 노드들의 최단 거리를 구하는 문제가 주어졌을 때 다익스트라 알고리즘을 사용한다. 

 

시간 복잡도(노드 수 : V, 에지 수 : E)

O(ElogV)

 

다익스트라 알고리즘 핵심 이론

1. 인접 리스트로 그래프 구현하기

   다익스트라 알고리즘은 인접 행렬로 구현해도 좋지만 시간 복잡도 측면, N의 크기가 클 것을 대비해 인접 리스트를 선택하여 구현하는 것 이 좋다. 

2. 최단 거리 배열 초기화하기

   최단 거리 배열을 만들고, 출발 노드는 0, 이외의 노드는 무한으로 초기화한다. 이때 무한은 적당히 큰 값을 사용하면 된다.

3. 값이 가장 작은 노드 고르기

   최단 거리 배열에서 현재 값이 가장 작은 노드를 고른다. 여기서는 값이 0인 출발 노드에서 시작하면 된다.

4. 최단 거리 배열 업데이트하기

   선택된 노드에 연결된 에지의 값을 바탕으로 다른 노드의 값을 업데이트합니다. 1단계에서 저장해 놓은 연결 리스트를 이용해 현재 선택된 노드의 에지들을 탐색하고 업데이트하면 된다. 연결 노드 간 최단 거리는 두 값 중 더 작은 값으로 업데이트한다.

5. 과정 3 ~ 4를 반복해 최단 거리 배열 완성하기

   모든 노드가 처리될 때까지 3 ~ 4를 반복한다. 과정 4에서 선택 노드가 될 때마다 다시 선택되지 않도록 방문 배열을 만들어 처리하고, 모든 노드가 선택될 때까지 반복하면 최단 거리 배열이 완성된다.

 

최단 거리 업데이트 방법

Min(선택 노드의 최단 거리 배열의 값 + 에지 가중치, 연결 노드의 최단 거리 배열의 값)

 

다익스트라 알고리즘은 출발 노드와 그외 노드 간의 최단 거리를 구하는 알고리즘이고, 에지는 항상 양수여야 한다는 제약 조건이 있다.

많은 사람들이 다익스트라 알고리즘이 출발 노드와 도착 노드 간의 최단 거리를 구하는 알고리즘이라고 생각하는 경향이 있는데, 실제로 완성된 배열은 출발 노드와 이외의 모든 노드 간의 최단 거리를 표현한다.

 

코드로 표현

static int[] distance;
static boolean[] visit;
static ArrayList<Edge>[] list;
static PriorityQueue<Edge> q = new PriorityQueue<Edge>();

for(int i = 1; i <= S; i++) {
	list[i] = new ArrayList<Edge>();
}
for(int i = 0; i <= S; i++) {
	distance[i] = Integer.MAX_VALUE;
}
for(int i = 0; i < E; i++) {  // 가중치가 있는 인접 리스트 초기화하기
	list[u].add(new Edge(v, w));
}
q.add(new Edge(k, 0));   // k를 시작점으로 설정하기
distance[k] = 0;
while(!q.isEmpty()) {
	Edge current = q.poll();
    int c_v = current.vertex;
    if(visit[c_v]) {
    	continue;   // 이미 방문한 적이 있는 노드는 다시 큐에 넣지 않음
    }
    visit[c_v] = true;
    for(int i = 0; i < list[c_v].size(); i++) {
    	Edge tmp = list[c_v].get(i);
        int next = tmp.vertex;
        int value = tmp.value;
        if(distance[next] > distance[c_v] + value) { // 최소 거리로 업데이트하기
        	distance[next] = value + distance[c_v];
            q.add(new Edge(next, distacne[next]));
        }
    }
 }
class Edge implements Comparable<Edge> {
	int vertex, value;
    Edge(int vertex, int value) {
    	this.vertex = vertex;
        this.value = value;
    }
    public int compareTo(Edge e) {
    	if(this.value > e.value) {
        	return 1;
        }
        else {
        	return -1;
        }
  	}
}

위의 코드는 알고리즘과 관련된 코드만 표현한 코드입니다. 생략된 부분이 많으니 참고 바랍니다.

728x90

'알고리즘 > 알고리즘 이론' 카테고리의 다른 글

플로이드-위셜  (0) 2022.06.23
벨만 - 포드  (0) 2022.06.21
위상 정렬  (0) 2022.06.21
유니온 파인드  (0) 2022.06.21
그리디  (0) 2022.06.20
728x90

위상 정렬

위상 정렬은 사이클이 없는 방향 그래프에서 노드 순서를 찾는 알고리즘입니다.

위상 정렬에서는 항상 유일한 값으로 정렬되지 않습니다. 또한 사이클이 존재하면 노드 간의 순서를 명확하게 정의할 수 없으므로 위상 정렬을 적용할 수 없습니다.

 

위상 정렬 핵심 이론

  1. 진입 차수는 자기 자신을 가리키는 에지의 개수이다. ArrayList로 그래프를 표현했다. 진입 차수 배열을 ArrayList로 표현한다. 만약 1에서 2, 3을 가리키면 D [2], D [3]을 각각 1만큼 증가시킨다.
  2. 진입 차수 배열에서 진입 차수가 0인 노드를 선택하고 선택된 노드를 정렬 배열에 저장한다. 그 후 인접리스트에서 선택된 노드가 가리키는 노드들의 진입 차수를 1씩 뺀다.
  3. 진입 차수가 0인 노드 1을 선택하여 2, 3의 진입 차수를 1씩 빼 D[2], D [3]을 0으로 만든다. 계속해서 모든 노드가 정렬될 때까지 반복한다. 여기서 진입 차수가 0인 노드를 위상 정렬 배열에 넣는다.

위상 정렬 수행 과정

  1. 진입 차수가 0인 노드를 큐에 저장
  2. 큐에서 데이터를 poll해 해당 노드를 탐색 결과에 추가하고, 해당 노드가 가리키는 노드의 진입 차수를 1씩 감소한다.
  3. 감소했을 때 진입 차수가 0이 되는 노드를 큐에 offer 한다.
  4. 큐가 빌 때까지 1 ~ 3을 반복한다.

시간 복잡도(노드 수: V, 에지 수: E)

O(V + E)

 

코드로 표현

ArrayList<ArrayList<Integer>> A = new ArrayList<>();  // 인접 리스트 
for(int i = 0; i <= n; i++) {
	A.add(new ArrayList<>());
}
int[] indegree = new int[n + 1]; // 진입 차수 배열
for(int i = 0; i < m; i++) {
	int s = sc.nextInt();
    int e = sc.nextInt();
    A.get(s).add(e);
    indegree[e]++;         // 진입 차수 배열 데이터 저장하기
}
Queue<Integer> que = new LinkedList<>();  // 위상 정렬 수행하기
for(int i = 1; i <= n; i++) { 
	if(indegree[i] == 0) {
    	que.offer(i);
    }
}
while(!que.isEmpty()) {
	int now = que.poll();
    for(int next : A.get(now)) {
    	indegree[next]--;
        if(indegree[next] == 0) {
        	que.offer(next);
        }
    }
}
728x90

'알고리즘 > 알고리즘 이론' 카테고리의 다른 글

벨만 - 포드  (0) 2022.06.21
다익스트라  (0) 2022.06.21
유니온 파인드  (0) 2022.06.21
그리디  (0) 2022.06.20
이진 탐색  (0) 2022.06.20
728x90

유니온 파인드

유니온 파인드는 일반적으로 여러 노드가 있을 때 특정 2개의 노드를 연결해 1개의 집합으로 묶는 union연산과 두 노드가 같은 집합에 속해 있는지를 확인하는 find 연산으로 구성되어 있는 알고리즘이다.

 

유니온 파인드 핵심 이론

union, find 연산

  • union 연산 : 각 노드가 속한 집합을 1개로 합치는 연산이다.
  • find 연산 : 특정 노드 a에 관해 a가 속한 집합의 대표 노드를 반환하는 연산이다.

유니온 파인드 원리 이해

유니온 파인드를 표현하는 일반적인 방식은 1차원 배열을 이용하는 것이다. 처음에는 노드가 연결되어 있지 않으므로 각 노드가 대표 노드가 된다. 각 노드가 모두 대표 노드이므로 배열은 자신의 인덱스 값으로 초기화한다. 2개의 노드를 선택해 각각의 대표 노드를 찾아 연결하는 union 연산을 수행한다. 배열을 보면 1, 4와 5, 6을 union연산으로 연결한다. 배열[4]은 1로, 배열[6]은 5로 업데이트한다. 1, 4의 연결을 예로 들어 1은 대표 노드, 4는 자식 노드로 union 연산을 하므로 배열[4]의 대표 노드를 1로 설정한 것이다. 다시 말해 자식 노드로 들어가는 노드 값 4를 대표 노드 값 1로 변경한 것이다. 그 결과 각각 집합이었던 1, 4는 하나로 합쳐진다. find 연산은 자신이 속한 집합의 대표 노드를 찾는 연산이다. find 연산은 단순히 대표 노드를 찾는 역할만 하는 것이 아니라 그래프를 정돈하고 시간 복잡도를 향상한다.

 

find 연산의 작동 원리

  1. 대상 노드 배열에 index값과 value값이 동일한지 확인
  2. 동일하지 않으면 value값이 가리키는 index위치로 이동
  3. 이동 위치의 index값과 value값이 같을 때까지 1, 2를 반복한다. 반복이므로 재귀 함수로 구현
  4. 대표 노드에 도달하면 재귀 함수를 빠져나오면서 거치는 모든 노드 값을 루트 노드 값으로 변경한다.

코드로 표현

private static void union(int s, int e) {
	s = find(s);
	e = find(e);
    if(s != e) {
		parent[e] = s;
	}
}
private static int find(int s) {
	if(s == parent[s]) {
		return s;
	}
	else {
		return parent[s] = find(parent[s]);
	}
}
728x90

'알고리즘 > 알고리즘 이론' 카테고리의 다른 글

다익스트라  (0) 2022.06.21
위상 정렬  (0) 2022.06.21
그리디  (0) 2022.06.20
이진 탐색  (0) 2022.06.20
BFS  (0) 2022.06.20
728x90

그리디

그리디 알고리즘은 현재 상태에서 볼 수 있는 선택지 중에 최선의 선택을 하는 알고리즘이다. 그리디 알고리즘은 동적 계획법보다 구현하기 쉽고 시간 복잡도가 우수하다. 하지만 항상 최적의 해를 보장하지 못한다는 단점도 있다.

 

그리디 알고리즘 핵심 이론

  1. 해 선택 : 현재 상태에서 가장 최선이라고 생각되는 해를 선택한다.
  2. 적절성 검사 : 현재 선택한 해가 전체 문제의 제약 조건에 벗어나지 않는지 검사한다.
  3. 해 검사 : 현재까지 선택한 해 집합이 전체 문제를 해결할 수 있는지 검사한다. 전체 문제를 해결하지 못한다면 1로 돌아가 같은 과정을 반복한다.

 

728x90

'알고리즘 > 알고리즘 이론' 카테고리의 다른 글

위상 정렬  (0) 2022.06.21
유니온 파인드  (0) 2022.06.21
이진 탐색  (0) 2022.06.20
BFS  (0) 2022.06.20
DFS  (0) 2022.06.20

+ Recent posts