728x90
반응형

 

신장트리(Spanning Tree)는 그래프 내의 모든 정점을 포함하는 트리입니다. MST(Minimum Spanning Tree)는 신장트리 중에서 사용된 간선들의 가중치 합이 최소인 트리를 이야기합니다. MST는 크루스칼 그리고 프림 알고리즘이 있습니다. 여기서는 프림알고리즘을 다루겠습니다.

 

  • 그래프 내의 간선의 숫자가 적은 희소 그래프의 경우 : 크루스칼 알고리즘
  • 그래프 내의 간선의 숫자가 많은 밀집 그래프의 경우 : 프림 알고리즘

 

동작방식

시작 정점에서부터 출발하여 신장트리 집합을 단계적으로 확장해 나가는 방법

  1. 시작 단계에서는 시작 정점만이 MST 에 포함합니다.
  2. 앞 단계에서 만들어진 MST 집합에 인접한 정점들 중에서 최소 간선으로 연결된 정점을 선택하여 트리를 확장합니다.
    • 즉, 가장 낮은 가중치를 먼저 선택합니다.
  3. 위의 과정을 트리가 N-1 개의 간선을 가질 때까지 반복합니다.

시간복잡도

기본적으로 O(N^2) 의 시간복잡도를 가지고 있습니다. 우선순위 큐를 사용한다면 O( E logV)의 시간복잡도를 가집니다.

참고사이트

https://hibee.tistory.com/300
 

[AL] 7. 최소 비용 신장 트리(MST) 알고리즘

7. 최소 비용 신장 트리(MST) 알고리즘 신장 트리 (Spanning Tree) 최소 비용 신장 트리 (MST) Kruskal MST 알고리즘 Prim MST 알고리즘 1. 신장 트리 (Spanning Tree) 1.1. Spanning Tree 그래프..

hibee.tistory.com

기본코드

7
11
1 2 2
2 3 5
1 3 20
1 4 10
4 5 1
5 6 23
3 6 3
3 5 6
7 6 9
7 3 2
2 7 7
package study.graph;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;

class B implements Comparable<B>{
	int n;
	int dist;
	
	B (int a, int b){
		this.n = a;
		this.dist = b;
	}

	@Override
	public int compareTo(B tar) {
		if(tar.dist < this.dist) return 1;
		if(tar.dist > this.dist) return -1;
		return 0;
	}
	
	
}

public class MST_프림 {

	public static void main(String[] args) throws IOException {
		
		System.setIn(new FileInputStream("input\\prim.txt"));
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		int N = Integer.parseInt(br.readLine());
		int M = Integer.parseInt(br.readLine());
		
		int[] used = new int[N+1]; // 방문 여부 (0: 미방문, 1: 방문)
		
		ArrayList<ArrayList<B>> alist = new ArrayList<ArrayList<B>>();
		for(int i=0; i<=N; i++) {
			alist.add(new ArrayList<B>());
		}
		
		StringTokenizer st = null;
		for(int m=1; m<=M; m++) {
			st = new StringTokenizer(br.readLine());
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());
			int dist = Integer.parseInt(st.nextToken());
			
			alist.get(a).add(new B(b, dist));
			alist.get(b).add(new B(a, dist));
		}
		
		PriorityQueue<B> pq = new PriorityQueue<B>();
		Queue<Integer> q = new LinkedList<Integer>();
		q.add(1); // 임의의 한 노드를 지정
		int sumDist = 0;
		
		while(!q.isEmpty()) {
			int currentNode = q.poll();
			used[currentNode] = 1; // 방문표시
			
			// 현재 노드에 연결된 간선을 pq에 넣음(방문한 노드는 제외)
			for(int i=0; i<alist.get(currentNode).size(); i++) {
				if(used[alist.get(currentNode).get(i).n] != 1) {
					pq.add(alist.get(currentNode).get(i));
				}
			}
			
			while(!pq.isEmpty()) {
				B tar = pq.poll();
				
				if(used[tar.n] == 1) continue; // 방문한 노드면 pass
				
				used[tar.n]= 1;// 방문표시
				sumDist += tar.dist;
				q.add(tar.n); // 연결된 노드를 큐에 넣어줌
				break; // pq에서 방문하지 않은 노드로 가는 가장 dist가 작은 것을 석택해주었으니 여기서 멈춤
			}
		}
		
		bw.write("# " + sumDist);
		
		bw.close();
		br.close();
		
	}
}
728x90
반응형
728x90
반응형

알고리즘 문제를 풀다보면 제곱근에 대한 문제가 종종 있습니다. 흔히 사용하는 math 의 pow 로 해결이 불가능 한 경우가 있습니다. 1024 이상의 제곱근을 사용하면 오류가 발생하거나 엉뚱한 숫자가 나타납니다. 이때 사용하는 것이 BigInteger 의 pow 입니다.  

아래는 BigInteger를 이용한 제곱근을 구하는 방법입니다. 그리고 나머지를 구해주는 remainder 까지 사용해 보았습니다.

package study.basic;

import java.math.BigInteger;

public class Big_Integer {

	public static void main(String[] args) {
		BigInteger big1, result;
		
		big1 = new BigInteger("2");
		int exponent=1245;
		
		result = big1.pow(exponent);
		
		String str = big1 + "^" + exponent + " = "  + result;
		System.out.println(str);
		
		int i = 1000000007;
		System.out.println( result.remainder(BigInteger.valueOf(i)));
	}
}

 

시험에 종종나오는 큰수의 경우 BigInteger를 사용하여 처리하면 간단히 구현이 가능합니다. 사용법을 꼭 숙지하십시오.

나머지 연산에 대한 내용은 아래 블로그를 참고하세요.

 

https://kkh0977.tistory.com/161
 

120. (java/자바) BigInteger 사용해 덧셈, 뺄셈, 곱셈, 나누기, 나머지, 최대공약수, 바이트값 구하기

/* =========================== */ [ 개발 환경 설정 ] ​ 개발 툴 : Eclipse 개발 언어 : Java /* =========================== */ ​ /* =========================== */ [소스 코드] package AI3; import jav..

kkh0977.tistory.com

728x90
반응형
728x90
반응형

동작방식

참고사이트 설명 참조

시간복잡도

 세그먼트 트리를 이용할 경우 기존의 for문이 O(N)의 시간 복잡도보다 빠른 O(logN)의 시간 복잡도

참고사이트

https://cocoon1787.tistory.com/313
 

[자료구조] 세그먼트 트리(구간트리, Segment Tree)로 구간 내 최소값 찾기

세그먼트 트리(Segment Tree)란? 알고리즘 문제를 풀다 보면 정렬되어 있지 않은 구간 내의 합이나 최솟값들을 빠르게 찾아야 하는 경우가 많습니다. 질문이 1개일 경우 간단하게 for문을 통해서 O(N)

cocoon1787.tistory.com

 

기본코드

10 4
75
30
100
38
50
51
52
20
81
5
1 10
3 5
6 9
8 10
package segmenttree;

import java.io.*;
import java.util.StringTokenizer;

public class Rmq {

    static int[] numbers;
    static int[][] questions;
    static int[] tree;

    public static void init(int node, int start, int end) {
        if (start == end) {
            tree[node] = numbers[start];
        } else {
            init(node*2, start, (start+end)/2);
            init(node*2+1, (start+end)/2+1, end);
            tree[node] = Math.min(tree[node*2],tree[node*2+1]);
        }
    }

    public static int query(int node, int start, int end, int a, int b) {
        if (a > end || b < start) {
            return -1;
        }
        if (a <= start && end <= b) {
            return tree[node];
        }
        int left = query(node*2, start, (start+end)/2, a, b);
        int right = query(node*2+1, (start+end)/2+1, end, a, b);
        if (left == -1) {
            return right;
        } else if (right == -1){
            return left;
        } else {
            return Math.min(left, right);
        }
    }

    public static void main(String[] args) throws IOException {

        System.setIn(new FileInputStream("input\\rmq.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        numbers = new int[N];
        questions = new int[M][2];
        tree = new int[N*4];

        for (int i=0; i<N; i++) {
            st = new StringTokenizer(br.readLine());
            numbers[i] = Integer.parseInt(st.nextToken());
        }

        for (int i=0; i<M; i++) {
            st = new StringTokenizer(br.readLine());
            questions[i][0] = Integer.parseInt(st.nextToken());
            questions[i][1] = Integer.parseInt(st.nextToken());
        }

        br.close();

        init(1, 0, N-1);

//        for (int i=0; i<tree.length; i++) {
//            System.out.println("tree[" + i + "] : " + tree[i]);
//        }

        for (int i=0; i<M; i++) {
            bw.write(query(1, 0, N-1, questions[i][0]-1, questions[i][1]-1)+"\n");
        }

        bw.flush();
        bw.close();
    }
}
728x90
반응형
728x90
반응형

Fenwick Tree는 Binary Indexed Tree라고도 하며, 줄여서 BIT라고 합니다.

동작방식

참고사이트에 자세한 동작 방식을 확인하여 주십시오.

시간복잡도

펜윅 트리는 대해 O(log n) 시간 복잡도를 가짐

참고사이트

https://www.acmicpc.net/blog/view/21
 

펜윅 트리 (바이너리 인덱스 트리)

블로그: 세그먼트 트리 (Segment Tree) 에서 풀어본 문제를 Fenwick Tree를 이용해서 풀어보겠습니다. Fenwick Tree는 Binary Indexed Tree라고도 하며, 줄여서 BIT라고 합니다. Fenwick Tree를 구현하려면, 어떤 수 X

www.acmicpc.net

기본코드

5 3
5 4 3 2 1
1 3
2 4
5 5
package segmenttree;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

public class Fenwick {

    static int N;
    static int M;
    static int[] numbers;
    static int[][] questions;
    static int[] tree;

    public static void update(int x, int val) {
        for (int i=x; i<=N; i+=i&-i) {
            tree[i] += val;
        }
    }

    public static int query(int x) {
        int ans = 0;
        for (int i=x; i>0; i-=i&-i) {
            ans += tree[i];
        }
        return ans;
    }

    public static void main(String[] args) throws IOException {

        System.setIn(new FileInputStream("input\\rsq.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());

        numbers = new int[N+1];
        questions = new int[M][2];
        tree = new int[N+1];

        st = new StringTokenizer(br.readLine());
        for (int i=1; i<=N; i++) {
            numbers[i] = Integer.parseInt(st.nextToken());
        }

        for (int i=0; i<M; i++) {
            st = new StringTokenizer(br.readLine());
            questions[i][0] = Integer.parseInt(st.nextToken());
            questions[i][1] = Integer.parseInt(st.nextToken());
        }

        br.close();

        for (int i=1; i<=N; i++) {
            update(i, numbers[i]);
        }

        for (int i=0; i<tree.length; i++) {
            System.out.println("tree[" + i + "] : " + tree[i]);
        }

        for (int i=0; i<M; i++) {
            bw.write((query(questions[i][1]) - query(questions[i][0]-1))+"\n");
        }

        bw.flush();
        bw.close();
    }
}

 

728x90
반응형
728x90
반응형

 

 

동작방식

맹목적 탐색방법의 하나로 탐색트리의 최근에 첨가된 노드를 선택하고, 이 노드에 적용 가능한 동작자 중 하나를 적용하여 트리에 다음 수준(level)의 한 개의 자식노드를 첨가하며, 첨가된 자식 노드가 목표노드일 때까지 앞의 자식 노드의 첨가 과정을 반복해 가는 방식입니다.

  • 장점
    • 단지 현 경로상의 노드들만을 기억하면 되므로 저장공간의 수요가 비교적 적다.
    • 목표노드가 깊은 단계에 있을 경우 해를 빨리 구할 수 있다.
  • 단점
    • 해가 없는 경로에 깊이 빠질 가능성이 있다. 따라서 실제의 경우 미리 지정한 임의의 깊이까지만 탐색하고 목표노드를 발견하지 못하면 다음의 경로를 따라 탐색하는 방법이 유용할 수 있다.
    • 얻어진 해가 최단 경로가 된다는 보장이 없다. 이는 목표에 이르는 경로가 다수인 문제에 대해 깊이우선 탐색은 해에 다다르면 탐색을 끝내버리므로, 이때 얻어진 해는 최적이 아닐 수 있다는 의미이다.

시간복잡도

- 인접리스트 : O(|V| + |E|) (정점의 개수:V, 간선의 개수:E)

- 인접행렬 : O(V^2) (정점의 개수:V)

참고사이트

https://ko.wikipedia.org/wiki/%EA%B9%8A%EC%9D%B4_%EC%9A%B0%EC%84%A0_%ED%83%90%EC%83%89
 

깊이 우선 탐색 - 위키백과, 우리 모두의 백과사전

깊이 우선 탐색의 애니메이션 예시 깊이 우선 탐색( - 優先探索, 영어: depth-first search, DFS)은 맹목적 탐색방법의 하나로 탐색트리의 최근에 첨가된 노드를 선택하고, 이 노드에 적용 가능한 동작

ko.wikipedia.org

기본코드

입력값

7
8
1 2
1 3
2 4
2 5
3 7
4 6
5 6
6 7  

코드

package study.graph;


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Stack;
import java.util.StringTokenizer;

public class DFS {
	static int[] used;
	static int[][] map;
	static int N, M;
	public static void main(String[] args) throws IOException{
		
		System.setIn(new FileInputStream("input\\dfs.txt"));
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		N = Integer.parseInt(br.readLine());
		M = Integer.parseInt(br.readLine());
		
		used = new int[N+1];
		map = new int[N+1][N+1]; // 인접행렬을 이용하기 위한 2차원 배열 생성
		
		StringTokenizer st = null;
		for(int m=0; m<M; m++) {
			st = new  StringTokenizer(br.readLine());
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());
			
			map[a][b] = 1;
			map[b][a] = 1; //양방향이기 때문에..
		}
		
		System.out.print("그래프 DFS 방문 순서 : " );
		dfs(1);
		
		bw.close();
		br.close();
	}
	
	static void dfs(int point) {
		Stack<Integer> st = new Stack<Integer>();
		st.add(point);
		used[point] = 1; // 방문표시
		System.out.print( point + " ");
		
		while(!st.isEmpty()) {
			st.pop();
			for(int i=1; i<=N; i++) {
				if(map[point][i]==1 && used[i] == 0) {
					// 다음 노드와 연결되어 있고 아직 방문하지 않았으면 st에 넣고, 재귀실행
					st.add(i);
					used[i] = 1;
					dfs(i);
				}
			}
		}
		
	}
}
728x90
반응형
728x90
반응형

 

동작방식

하나로 시작 정점을 방문한 후 시작 정점에 인접한 모든 정점들을 우선 방문하는 방법입니다. 더 이상 방문하지 않은 정점이 없을 때까지 방문하지 않은 모든 정점들에 대해서도 너비 우선 검색을 적용합니다.

 

장점

  • 출발노드에서 목표노드까지의 최단 길이 경로를 보장한다.

단점

  • 경로가 매우 길 경우에는 탐색 가지가 급격히 증가함에 따라 보다 많은 기억 공간을 필요로 하게 된다.
  • 해가 존재하지 않는다면 유한 그래프(finite graph)의 경우에는 모든 그래프를 탐색한 후에 실패로 끝난다.
  • 무한 그래프(infinite graph)의 경우에는 결코 해를 찾지도 못하고, 끝내지도 못한다.

 

시간복잡도

DFS 시간복잡도와 동일함

- 인접리스트 : O(|V| + |E|) (정점의 개수:V, 간선의 개수:E)

- 인접행렬 : O(V^2) (정점의 개수:V)

참고사이트

https://ko.wikipedia.org/wiki/%EB%84%88%EB%B9%84_%EC%9A%B0%EC%84%A0_%ED%83%90%EC%83%89
 

너비 우선 탐색 - 위키백과, 우리 모두의 백과사전

 

ko.wikipedia.org

기본코드

입력값

7
8
1 2
1 3
2 4
2 5
3 7
4 6
5 6
6 7  

코드

package study.graph;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class BFS {

	static int[] used;
	static int[][] map;
	static int N, M;
	public static void main(String[] args) throws IOException{
		
		System.setIn(new FileInputStream("input\\bfs.txt"));
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		N = Integer.parseInt(br.readLine());
		M = Integer.parseInt(br.readLine());
		
		used = new int[N+1];
		map = new int[N+1][N+1]; // 인접행렬을 이용하기 위한 2차원 배열 생성
		
		StringTokenizer st = null;
		for(int m=0; m<M; m++) {
			st = new  StringTokenizer(br.readLine());
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());
			
			map[a][b] = 1;
			map[b][a] = 1; //양방향이기 때문에..
		}
		
		System.out.print("그래프 BFS 방문 순서 : " );
		bfs(1);
		
		bw.close();
		br.close();
	}
	
	static void bfs(int st) {
		Queue<Integer> q = new LinkedList<Integer>();
		q.add(st);
		used[st] = 1; //방문표시
		
		while(!q.isEmpty()) {
			int x = q.poll();
			System.out.print( x + " ");
			
			for(int i=1; i<=N; i++) {
				if(map[x][i] == 1 && used[i] == 0) {
					// 다음 노드와 연결되어 있고 아직 방문하지 않았으면 q에 넣음
					q.add(i);
					used[i] = 1;//방문 표시
				}
			}
		}
	}
}
728x90
반응형
728x90
반응형

세그먼트 트리를 이용하여 구간의 합을 빨리 찾는 문제를 설명하도록 하겠습니다. 이번 포스팅은 영상을 찍어봤는데, 처음이라 자연스럽지 못하지만 나름 열심히 설명하려 노력했습니다. 어색하더라도 양해해 주십시오.

이론설명

 


초기설정구현

    public static int init(int node, int start, int end) {
        if (start == end) {
            tree[node] = numbers[start];
        } else {
            int left = init(node*2, start, (start+end)/2);
            int right = init(node*2+1, (start+end)/2+1, end);
            tree[node] = left+right;
        }
        return tree[node];
    }


구간합 찾기 구현

    public static int query(int node, int start, int end, int a, int b) {
        if (a > end || b < start) {
            return 0;
        }
        if (a <= start && end <= b) {
            return tree[node];
        }
        int left = query(node*2, start, (start+end)/2, a, b);
        int right = query(node*2+1, (start+end)/2+1, end, a, b);
        return left + right;
    }

 

 

전체코드

import java.io.*;
import java.util.StringTokenizer;

public class Rsq {

    static int[] numbers;
    static int[][] questions;
    static int[] tree;

    public static int init(int node, int start, int end) {
        if (start == end) {
            tree[node] = numbers[start];
        } else {
            int left = init(node*2, start, (start+end)/2);
            int right = init(node*2+1, (start+end)/2+1, end);
            tree[node] = left+right;
        }
        return tree[node];
    }

    public static int query(int node, int start, int end, int a, int b) {
        if (a > end || b < start) {
            return 0;
        }
        if (a <= start && end <= b) {
            return tree[node];
        }
        int left = query(node*2, start, (start+end)/2, a, b);
        int right = query(node*2+1, (start+end)/2+1, end, a, b);
        return left + right;
    }

    public static void main(String[] args) throws IOException {

        System.setIn(new FileInputStream("input\\rsq.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        numbers = new int[N];
        questions = new int[M][2];
        tree = new int[N*4];

        st = new StringTokenizer(br.readLine());
        for (int i=0; i<N; i++) {
            numbers[i] = Integer.parseInt(st.nextToken());
        }

        for (int i=0; i<M; i++) {
            st = new StringTokenizer(br.readLine());
            questions[i][0] = Integer.parseInt(st.nextToken());
            questions[i][1] = Integer.parseInt(st.nextToken());
        }

        br.close();

        init(1, 0, N-1);

        for (int i=0; i<tree.length; i++) {
            System.out.println("tree[" + i + "] : " + tree[i]);
        }

        for (int i=0; i<M; i++) {
            bw.write(query(1, 0, N-1, questions[i][0]-1, questions[i][1]-1)+"\n");
        }

        bw.flush();
        bw.close();
    }
}
[input : input\rsq.txt]
5 3
5 4 3 2 1
1 3
2 4
5 5
[output]
12
9
1
728x90
반응형
728x90
반응형

인접 리스트는 그래프 이론에서 그래프를 표현하기 위한 방법 중 하나입니다. 그래프의 한 꼭짓점에서 연결되어 있는 꼭짓점들을 하나의 연결 리스트로 표현하는 방법입니다. 인접 행렬에 비하여 변이 희소한 그래프에 효율적 입니다.

동작방식

아래와 같은 그래프가 존재할때 인접행렬을 만들어 보겠습니다. 1노드에서 시작하여 2,3 노드로 연결됩니다. 그리고 3노드는 2,4 노드로 연결됩니다. 이는 단방향을 나타내고 있음을 알수 있습니다. 2차원 배열을 준비하고 배열의 Y축을 시작 좌표, 배열의 X축을 그래프가 향하는 노드라고 생각을하고 아래 그림과 같이 만들어 사용을 합니다.

참고사이트

https://ko.wikipedia.org/wiki/%EC%9D%B8%EC%A0%91_%EB%A6%AC%EC%8A%A4%ED%8A%B8
 

인접 리스트 - 위키백과, 우리 모두의 백과사전

 

ko.wikipedia.org

 

기본코드

위 그래프를 만드는 방법과 간단히 순환하는 순서를 나타내는 코드입니다.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;

public class Test {

    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

    static ArrayList<ArrayList<Integer>> alist = new ArrayList<ArrayList<Integer>>();

    static void run(int now)
    {
        System.out.print(now + " ");

        for (int i = 0; i<alist.get(now).size(); i++) {
            run(alist.get(now).get(i));
        }
    }

    public static void main(String[] args) throws IOException {        

        for (int i = 0; i < 5; i++) {
            alist.add(new ArrayList<>());
        }

        alist.get(1).add(2);
        alist.get(1).add(3);
        alist.get(3).add(2);
        alist.get(3).add(4);

        run(1);

        br.close();
        bw.close();        
    }
}

결과는 "1 2 3 2 4 "로 나타납니다.

728x90
반응형
728x90
반응형

PriorityQueue 는 우선순위가 가장 높은것을 빼는 규칙입니다.

 

동작방식

  1. 자료를 넣는다.
  2. 자료 삭제시 가장 우선순위 높은걸 삭제,
  3. 자료 읽을때 우선순위 가장 높은것을 읽는다.

시간복잡도

자료를 넣고 빼는 속도 모두 : logN

기본코드

PriorityQueue의 기본코드 입니다.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Collections;
import java.util.PriorityQueue;


public class PriorityQueue_example_0 {

	/**
	 * Priority Queue - Heap 으로 가장 많이 구현되어있다.
	 *  - 먼저넣은 것중 우선순위가 높은 것을 뺀다.
	 *  - 자료를 넣고 빼는 속도 모두 : logN
	 *  - max, min 값 찾기에 많이 쓰임
	 */
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

	
    public static void main(String[] args) throws IOException {

        // min heap - 가장 위(0)가 가장 작은값 
        PriorityQueue<Integer> q = new PriorityQueue<Integer>();
        
        q.add(5);
        q.add(3);
        q.add(7);
        q.add(4);
        q.add(5);
        
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        System.out.println(q.poll());
        
        System.out.println("=======================");
        // max heap - 가장 위(0)가 가장 큰값 
        PriorityQueue<Integer> qr = new PriorityQueue<Integer>(Collections.reverseOrder());
        
        qr.add(5);
        qr.add(3);
        qr.add(7);
        qr.add(4);
        qr.add(5);
        
        // 빼지않고, 가장 우선순위 
        
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        System.out.println(qr.poll()); // 가장 큰 하나를 제거하고 출력
        // --> 힙소트
        
		br.close();
		bw.close();

    }
}

결과는 다음과 같습니다.

3
4
5
5
7
null
=======================
7
5
5
4
3
null

 

아래는 class를 PriorityQueue에 넣어 우선순위를 조절해주어 실행해보는 코드입니다.

import java.io.IOException;
import java.util.PriorityQueue;

class Nodes implements Comparable<Nodes> {
    int a;
    int b;

    Nodes(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public int compareTo(Nodes tar) {
        if (tar.a > this.a) return 1;
        if (tar.a < this.a) return -1;
        
        if(tar.b > this.b) return 1;
        if(tar.b < this.b) return -1;
        return 0;

    }

}

public class PriorityQueue_example_1 {
    public static void main(String[] args) throws IOException {

        PriorityQueue<Nodes> q = new PriorityQueue<Nodes>();

        q.add(new Nodes(1, 2));
        q.add(new Nodes(5, 1));
        q.add(new Nodes(5, 3));
        q.add(new Nodes(1, 2));
        q.add(new Nodes(4, 6));

        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
        System.out.println(q.peek().a + " " + q.peek().b);
        q.poll();
    }
}

결과는 아래와 같습니다.

5 3
5 1
4 6
1 2
1 2

compareTo 함수를 오버라이드하여 class 내부적으로 순서를 조절하여 우선순위를 만들어 첫번째 숫자가 큰순, 두번째 수가 큰순으로 우선순위를 부여하여 큐에서 빼낸 결과입니다.

728x90
반응형
728x90
반응형

이번에는 슬라이딩 윈도우 알고리즘과 DAT 자료구조를 이용한 간단한 문제를 풀어보겠습니다.

 

문제

입력된 문자열(알파벳)에서 길이가 M개의 구간에서 가장 많이 등장하는 알파벳을 출력하라

문자열 : "AAAABBBBAABKKKABKKKKDKAAA"
M: 6

코드

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


public class SlidingWindow_DAT {

	
	/**
	 * 슬라이등 윈도우 + DAT
	 */
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));


    public static void main(String[] args) throws IOException {        

        String str = "AAAABBBBAABKKKABKKKKDKAAA";
        int n = str.length();
        int m = 6;

        int[] dat = new int[100];

        //초기세팅 6개 DAT
        char maxCh = ' ';
        int maxCnt = 0;

        for (int i = 0; i<m; i++) {
            dat[str.charAt(i)]++;
            if (dat[str.charAt(i)] > maxCnt) {
                maxCnt = dat[str.charAt(i)];
                maxCh = str.charAt(i);
            }
        }

        //슬라이딩 윈도우
        for (int i = 0; i<n - m; i++) {            
            //다음 준비
            dat[str.charAt(i + m)]++;            
            dat[str.charAt(i)]--;    

            if (dat[str.charAt(i + m)] > maxCnt) {
                maxCnt = dat[str.charAt(i + m)];
                maxCh = str.charAt(i + m);
            }
        }

        System.out.println(maxCh);

        bw.close();
        br.close();
    }    

}

풀이

dat 배열에 길이가 M인 구간에서 나타나는 알파벳을 카운트하여 줍니다. 문자열 AAAABBBBAABKKKABKKKKDKAAA에서 처음 AAAABB 를 확인하면 dat 배열 dat['A']는 4, dat['B'] 는 2가 들어갑니다. 그리고 다음으로 이동합니다. 슬라이딩 윈도우 알고리즘으로 길이가 6인 구간을 기준으로 뒤문자는 카운트를 더해주고, 앞문자는 카운트에서 빼줍니다. 작업이 완려되면 dat배열에 문자번째와 max변수를 비교하여 max변수를 갱신합니다. 이러한 방식으로 M구간에서 가장 많이 나오는 알파벳을 알아낼 수 있습니다.

728x90
반응형

+ Recent posts