posted by 귀염둥이채원 2019. 3. 13. 16:55

# 문제링크

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


# 알고리즘

- Segment Tree를 사용해서 풀어야 한다.

- https://palyoung.tistory.com/64


# 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
package segment;
 
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Main {
    static int N, M, K;
    static int arr[];
    public static void main(String[] args) throws IOException {
        //System.setIn(new FileInputStream("src\\sample.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        StringBuilder sb = new StringBuilder();
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());
        
        arr = new int[N];
        int a=0, b=0, c=0;
        
        for (int i=0; i<N; i++) {
            arr[i] = Integer.parseInt(br.readLine());
        }
        
        SegmentTree seg = new SegmentTree(arr, N);
        //seg.print();
        
        for (int i=0; i<M+K; i++) {
            st = new StringTokenizer(br.readLine());
            a = Integer.parseInt(st.nextToken());
            b = Integer.parseInt(st.nextToken());
            c = Integer.parseInt(st.nextToken());
            
            // segment tree 업데이트
            if (a == 1) {
                seg.update(b-1, c, 10, N-1);
            }
            // segment tree에서 구간의 합 
            else if (a == 2) {
                sb.append(seg.query(b-1, c-110, N-1)+"\n");
            }
        }
        System.out.println(sb);
    }
}
 
class SegmentTree {
    long SegmentTreeArr[];    // segment tree node 데이터
    
    SegmentTree(int arr[], int N) {
        SegmentTreeArr = new long[N*4];
        init(arr, 0, N-11);
    }
    
    // Leaf Node가 N개인 Segment Tree 생성
    // node 의 왼쪽 자식은 node*2, 오른쪽 자식은 node*2+1
    long init(int arr[], int left, int right, int node) {
        // node가 리프 노드인 경우
        if (left == right) return SegmentTreeArr[node] = arr[left];
        int mid = (left+right)/2;
        return SegmentTreeArr[node] = init(arr, left, mid, node*2+ init(arr, mid+1, right, node*2+1);
    }
    
    // Segment Tree를 갱신하고 노드 구간의 합을 구한다.
    long update(int index, int value, int node, int nodeLeft, int nodeRight) {
        // index가 Node 구간에 포함되지 않는 경우
        if (index < nodeLeft || index > nodeRight) return SegmentTreeArr[node];
        
        // node가 리프 노드인 경우
        if (nodeLeft == nodeRight)  return SegmentTreeArr[node] = value; 
        
        int mid = (nodeLeft + nodeRight)/2;
        return SegmentTreeArr[node] = update(index, value, node*2, nodeLeft, mid) + update(index, value, node*2+1, mid+1, nodeRight); 
    }
    
    // Segment Tree의 구간 합을 구한다.
    long query(int left, int right, int node, int nodeLeft, int nodeRight) {
        // 두 구간이 겹치지 않는 경우
        if (left > nodeRight || right < nodeLeft) return 0;
        
        // [left, right]가 [nodeLeft, nodeRight]를 포함하는 경우
        if (left <= nodeLeft && right >= nodeRight) return SegmentTreeArr[node];
        
        int mid = (nodeLeft + nodeRight)/2;
        return query(left, right, node*2, nodeLeft, mid) + query(left, right, node*2+1, mid+1, nodeRight); 
    }
    
    void print() {
        for (int i=0; i<SegmentTreeArr.length; i++) {
            System.out.printf("%d, ", SegmentTreeArr[i]);
        }
        System.out.println();
    }
}
cs


'PS(Problem Solving) > Segment Tree' 카테고리의 다른 글

최솟값과 최댓값  (0) 2019.03.14
[BOJ]10868. 최솟값  (0) 2019.03.13
posted by 귀염둥이채원 2019. 3. 11. 11:33

# 디렉토리 삭제

$ git rm -r --cached {directory name}

* git rm --> 원격 저장소와 로컬 저장소에 있는 파일을 삭제한다.

* git rm --cached --> 원격 저장소에 있는 파일을 삭제한다. 로컬 저장소에 있는 파일은 삭제하지 않는다.


# git commit

$ git commit -m "remove {directory name} directory"


# git push

$ git push origin master

'Tool > git' 카테고리의 다른 글

Git commit --amend로 마지막 커밋 수정하기  (0) 2019.02.08
git submodule이란?  (0) 2019.02.08
git commit --amend 오류  (0) 2019.01.24
posted by 귀염둥이채원 2019. 3. 4. 21:20

TreeSet, TreeMap은 이진 트리(binary tree)를 이용해서 계층적 구조(Tree 구조)를 가지면서 객체를 저장합니다.


# TreeSet

- 하나의 노드는 노드 값인 value와 왼쪽과 오른쪽 자식 노드를 참조하기 위한 두 개의 변수로 구성

- TreeSet에 객체를 저장하면 자동으로 정렬되는데 부모값과 비교해서 낮은 것은 왼쪽 노드에, 높은 것은 오른쪽 노드에 저장

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class TreeSetExam1 {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<Integer>();
         
        for (int i = 1; i <= 10; i++) {
            treeSet.add(new Integer(i*10));
        }
 
        Integer score = null;
 
        score = treeSet.first();
        System.out.println("가장 낮은 점수: " + score);
 
        score = treeSet.last();
        System.out.println("가장 높은 점수: " + score);
 
        score = treeSet.lower(new Integer(90));
        System.out.println("90점 아래 점수: " + score);
 
        score = treeSet.higher(new Integer(90));
        System.out.println("90점 위 점수: " + score);
    }
}
 
/********* 결과 *********
가장 낮은 점수: 10
가장 높은 점수: 100
90점 아래 점수: 80
90점 위 점수: 100
*/
cs


# TreeMap

- TreeSet과 차이점은 키와 값이 저장된 Map.Entry를 저장한다는 점

- TreeMap에 객체를 저장하면 자동으로 정렬되는데, 기본적으로 부모 키값과 비교해서 키 값이 낮은 것은 왼쪽 노드에, 키 값이 높은 것은 오른쪽 노드에 Map.Entry에 저장

★★API 그림 추가

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.Map;
import java.util.TreeMap;
 
public class TreeMapExam1 {
    public static void main(String[] args) {
        TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();
 
        treeMap.put(new Integer(90), "Jack");
        treeMap.put(new Integer(77), "Mike");
        treeMap.put(new Integer(82), "Jolie");
        treeMap.put(new Integer(93), "Sminoph");
        treeMap.put(new Integer(67), "Neil");
        treeMap.put(new Integer(55), "Max");
 
        Map.Entry<Integer, String> entry = null;
 
        entry = treeMap.firstEntry();
        System.out.println("가장 낮은 점수: " + entry.getKey() + "-" + entry.getValue());
 
        entry = treeMap.lastEntry();
        System.out.println("가장 높은 점수: " + entry.getKey() + "-" + entry.getValue());
 
        entry = treeMap.lowerEntry(new Integer(95));
        System.out.println("95점 아래 점수: " + entry.getKey() + "-" + entry.getValue());
 
        while (!treeMap.isEmpty()) {
            entry = treeMap.pollFirstEntry();
            System.out.println(entry.getKey() + "-" + entry.getValue() + " (남은 객체 수: " + treeMap.size() + ")");
        }
    }
}
 
/********* 결과 *********
가장 낮은 점수: 55-Max
가장 높은 점수: 93-Sminoph
95점 아래 점수: 93-Sminoph
55-Max (남은 객체 수: 5)
67-Neil (남은 객체 수: 4)
77-Mike (남은 객체 수: 3)
82-Jolie (남은 객체 수: 2)
90-Jack (남은 객체 수: 1)
93-Sminoph (남은 객체 수: 0)
*/
cs


# 참고사이트

★★https://palpit.tistory.com/657

https://lapan.tistory.com/61

https://hackersstudy.tistory.com/26

https://12bme.tistory.com/91