www.acmicpc.net/problem/2110

 

2110번: 공유기 설치

첫째 줄에 집의 개수 N (2 ≤ N ≤ 200,000)과 공유기의 개수 C (2 ≤ C ≤ N)이 하나 이상의 빈 칸을 사이에 두고 주어진다. 둘째 줄부터 N개의 줄에는 집의 좌표를 나타내는 xi (0 ≤ xi ≤ 1,000,000,000)가

www.acmicpc.net

M개의 공유기를 놓을 수 있는 최대한의 간격을 구하는 문제입니다.

최대한의 간격은 최적화된 정답을 구하는 것이므로 파라매트릭 서치로 해결합니다.

 

우선 이분탐색을 쓰기 위해 입력받은 위치정보를 정렬합니다.

탐색 범위는 간격이며, (1 ~ list[N] - list[1])의 범위에서 탐색합니다.

 

간격 m에서 공유기를 M개 이상 놓을 수 있는지 확인합니다.

놓을 수 있으면 true, 아니면 false를 리턴합니다.

 

solve함수의 리턴 값이 true면 ans에 현재 간격을 저장하고 (m + 1 ~ r) 범위를 탐색합니다.

solve함수의 리턴 값이 false면 (s ~ m - 1) 범위를 탐색합니다.

 

모든 간격을 확인 하였을 때 지금까지 구했던 최적의 간격을 출력합니다.

 

 

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
#include <iostream>
#include <algorithm>
using namespace std;
 
int list[200001];
int N, M;
 
bool solve(int length) {
    int pre = list[1];
    int cnt = 1;
    for (int i = 2; i <= N; i++) {
        if (list[i] - pre >= length) {
            cnt++;
            pre = list[i];
        }
    }
 
    if (cnt >= M) return true;
    else return false;
}
 
int binarySearch(int l, int r) {
    int ans = 0;
 
    while (l <= r) {
        int m = (l + r) / 2;
        if (solve(m)) {
            ans = m;
            l = m + 1;
        }
        else r = m - 1;
    }
 
    return ans;
}
 
void input() {
    cin >> N >> M;
    for (int i = 1; i <= N; i++) {
        cin >> list[i];
    }
    sort(list + 1, list + 1 + N);
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    cout << binarySearch(1, list[N] - list[1]) << '\n';
 
    return 0;
}
cs

'algorithm > binarysearch' 카테고리의 다른 글

boj 18113 그르다 김가놈  (0) 2022.10.09
boj 2295 세 수의 합  (0) 2022.06.28
boj 7453 합이 0인 네 정수  (0) 2021.01.22
boj 2143 두 배열의 합  (0) 2021.01.22
boj 2805 나무 자르기  (0) 2021.01.22

www.acmicpc.net/problem/2243

 

2243번: 사탕상자

첫째 줄에 수정이가 사탕상자에 손을 댄 횟수 n(1≤n≤100,000)이 주어진다. 다음 n개의 줄에는 두 정수 A, B, 혹은 세 정수 A, B, C가 주어진다. A가 1인 경우는 사탕상자에서 사탕을 꺼내는 경우이다.

www.acmicpc.net

사탕의 맛이 1 ~ 1000000 까지 있습니다.

저는 맛을 인덱스로 하여 세그먼트 트리를 사용하여 구간 합을 구현하였습니다.

 

A가 1일 때, B는 꺼낼 사탕의 순위입니다.

A가 2일 때, B는 넣는 사탕의 맛이고, C는 갯수이며 양수면 넣는 경우, 음수면 빼는 경우입니다.

 

A = 2가 들어오면 B 인덱스에 C만큼 추가하면 되겠고

A = 1이 들어오면 사탕의 순위를 이분탐색으로 찾습니다.

 

이분탐색은 세그먼트 트리의 값을 이용하여 범위를 찾습니다.

x가 왼쪽 자식노드의 수보다 작거나 같으면 (tree[node * 2] >= x) l ~ m 범위로 내려가고 (더 낮은 구역을 탐색)

x가 왼쪽 자식노드의 수보다 크면 (tree[node * 2 < x) m + 1 ~ r의 범위로 내려갑니다. (더 높은 구역을 탐색)

이 때 m + 1 ~ r의 범위로 이동할 때 오른쪽 자식노드의 순위를 판단해야 하기때문에 x - tree[node * 2] 한 값을 보내줍니다.

 

마지막으로 l == r 구역에 도달하면 사탕을 한개 빼줘야하므로 update를 해주고 찾은 인덱스를 리턴해줍니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Main {
    static final int MAX = 1000000;
    static int tree[] = new int[(MAX + 1* 4];
    static int N;
 
    static void update(int node, int s, int e, int idx, int diff) {
        if (idx < s || idx > e)
            return;
 
        if (s == e) {
            tree[node] += diff;
            return;
        }
 
        tree[node] += diff;
        int m = (s + e) / 2;
        update(node * 2, s, m, idx, diff);
        update(node * 2 + 1, m + 1, e, idx, diff);
    }
 
    static int binarysearch(int node, int l, int r, int x) {
        if (l == r) {
            update(11, MAX, l, -1);
            return l;
        }
 
        int m = (l + r) / 2;
        if (tree[node * 2>= x)
            return binarysearch(node * 2, l, m, x);
        else
            return binarysearch(node * 2 + 1, m + 1, r, x - tree[node * 2]);
    }
 
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        StringBuffer sb = new StringBuffer();
 
        N = Integer.parseInt(st.nextToken());
        while (N-- > 0) {
            st = new StringTokenizer(br.readLine());
            int type = Integer.parseInt(st.nextToken());
 
            if (type == 1) {
                int a = Integer.parseInt(st.nextToken());
                sb.append(binarysearch(11, MAX, a)).append("\n");
            } else {
                int a = Integer.parseInt(st.nextToken());
                int b = Integer.parseInt(st.nextToken());
 
                update(11, MAX, a, b);
            }
        }
 
        System.out.println(sb.toString());
    }
}
cs

'algorithm > SegmentTree' 카테고리의 다른 글

boj 14438 수열과 쿼리 17  (0) 2021.02.21
boj 13537 수열과 쿼리 1  (0) 2021.02.21
boj 6549 히스토그램에서 가장 큰 직사각형  (0) 2021.02.19
boj 2104 부분배열 고르기  (0) 2021.02.19
boj 2042 구간 합 구하기  (0) 2021.01.23

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

 

7453번: 합이 0인 네 정수

첫째 줄에 배열의 크기 n (1 ≤ n ≤ 4000)이 주어진다. 다음 n개 줄에는 A, B, C, D에 포함되는 정수가 공백으로 구분되어져서 주어진다. 배열에 들어있는 정수의 절댓값은 최대 228이다.

www.acmicpc.net

upperbound와 lowerbound를 연습하기 위해 풀었습니다..

 

emoney96.tistory.com/36

 

이 문제도 위의 문제와 같이 두 그룹으로 나눠서 이분탐색을 통해 값의 조합을 구하는 문제입니다.

 

먼저 list가 4개씩 주어지는데 크기가 4000이므로 2차원 배열을 이용하여 두 그룹으로 나눠줍니다.

 

그 다음 이분탐색으로 합이 0이되는 조합의 갯수를 upperbound-lowerbound로 찾아주면 되겠습니다.

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int list[][], N;
    static long sumlist[][], ans;
 
    static int upperbound(int l, int r, long x) {
        while (l < r) {
            int m = (l + r) / 2;
            if (sumlist[1][m] <= x)
                l = m + 1;
            else
                r = m;
        }
 
        return l;
    }
 
    static int lowerbound(int l, int r, long x) {
        while (l < r) {
            int m = (l + r) / 2;
            if (sumlist[1][m] < x)
                l = m + 1;
            else
                r = m;
        }
 
        return r;
    }
 
    static void binarysearch(int l, int r, long x) {
        if (l > r)
            return;
 
        int m = (l + r) / 2;
        if (sumlist[1][m] + x == 0) {
            ans += (upperbound(0, N * N, sumlist[1][m]) - lowerbound(0, N * N, sumlist[1][m]));
            return;
        } else if (sumlist[1][m] + x < 0)
            binarysearch(m + 1, r, x);
        else
            binarysearch(l, m - 1, x);
    }
 
    static void func() {
        Arrays.sort(sumlist[1]);
        for (int i = 0; i < N * N; i++) {
            binarysearch(0, N * N - 1, sumlist[0][i]);
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new int[4][N];
        sumlist = new long[2][N * N];
 
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            list[0][i] = Integer.parseInt(st.nextToken());
            list[1][i] = Integer.parseInt(st.nextToken());
            list[2][i] = Integer.parseInt(st.nextToken());
            list[3][i] = Integer.parseInt(st.nextToken());
        }
 
        for (int i = 0, k = 0; i < N; i++) {
            for (int j = 0; j < N; j++, k++) {
                sumlist[0][k] = list[0][i] + list[1][j];
                sumlist[1][k] = list[2][i] + list[3][j];
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
        System.out.println(ans);
    }
}
cs

'algorithm > binarysearch' 카테고리의 다른 글

boj 2295 세 수의 합  (0) 2022.06.28
boj 2110 공유기 설치  (0) 2021.04.13
boj 2143 두 배열의 합  (0) 2021.01.22
boj 2805 나무 자르기  (0) 2021.01.22
boj 1920 수 찾기  (0) 2021.01.22

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

 

2143번: 두 배열의 합

첫째 줄에 T(-1,000,000,000 ≤ T ≤ 1,000,000,000)가 주어진다. 다음 줄에는 n(1 ≤ n ≤ 1,000)이 주어지고, 그 다음 줄에 n개의 정수로 A[1], …, A[n]이 주어진다. 다음 줄에는 m(1≤m≤1,000)이 주어지고, 그 다

www.acmicpc.net

A배열의 연속 합 + B배열의 연속 합의 조합을 찾는 문제입니다.

 

A와 B 배열 각각의 연속합을 모두 저장한 후 이분탐색으로 사용하였습니다.

 

Alist의 값과 더할 Blist의 값을 이분탐색으로 찾아야하는데 중복된 값이 들어있을 수 있으므로 upper bound와 lower bound를 이용해야합니다.

 

C++에는 upper_bound와 lower_bound가 지원되어 편리하지만 JAVA에는 없어서..

직접구현 해본적도 없는 얘내들 구현한다고 고생좀 했습니다 ㅠㅠ

 

 

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
98
99
100
101
102
103
104
105
106
107
108
109
110
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int A[], B[], Adp[], Bdp[];
    static ArrayList<Long> Alist, Blist;
    static int N, M;
    static long T, ans;
 
    static void init() {
        Alist = new ArrayList<>();
        Blist = new ArrayList<>();
        for (int i = 1; i <= N; i++) {
            for (int j = i; j <= N; j++) {
                Alist.add((long) (Adp[j] - Adp[i - 1]));
            }
        }
 
        for (int i = 1; i <= M; i++) {
            for (int j = i; j <= M; j++) {
                Blist.add((long) (Bdp[j] - Bdp[i - 1]));
            }
        }
 
        Collections.sort(Alist);
        Collections.sort(Blist);
    }
 
    static long upperbound(int l, int r, long x) {
        r++;
        while (l < r) {
            int m = (l + r) / 2;
            if (Blist.get(m) <= x)
                l = m + 1;
            else
                r = m;
        }
        return l;
    }
 
    static long lowerbound(int l, int r, long x) {
        r++;
        while (l < r) {
            int m = (l + r) / 2;
            if (Blist.get(m) < x)
                l = m + 1;
            else
                r = m;
        }
        return r;
    }
 
    static void binarysearch(int l, int r, long x) {
        if (l > r)
            return;
 
        int m = (l + r) / 2;
        long sum = x + Blist.get(m);
        if (sum == T) {
            ans += (upperbound(0, Blist.size() - 1, Blist.get(m)) - lowerbound(0, Blist.size() - 1, Blist.get(m)));
            return;
        } else if (sum > T)
            binarysearch(l, m - 1, x);
        else
            binarysearch(m + 1, r, x);
    }
 
    static void func() {
        for (int i = 0; i < Alist.size(); i++) {
            binarysearch(0, Blist.size() - 1, Alist.get(i));
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        T = Integer.parseInt(st.nextToken());
 
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        A = new int[N + 1];
        Adp = new int[N + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            A[i] = Integer.parseInt(st.nextToken());
            Adp[i] = Adp[i - 1+ A[i];
        }
 
        st = new StringTokenizer(br.readLine());
        M = Integer.parseInt(st.nextToken());
        B = new int[M + 1];
        Bdp = new int[M + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= M; i++) {
            B[i] = Integer.parseInt(st.nextToken());
            Bdp[i] = Bdp[i - 1+ B[i];
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        init();
        func();
        System.out.println(ans);
    }
}
cs

'algorithm > binarysearch' 카테고리의 다른 글

boj 2110 공유기 설치  (0) 2021.04.13
boj 7453 합이 0인 네 정수  (0) 2021.01.22
boj 2805 나무 자르기  (0) 2021.01.22
boj 1920 수 찾기  (0) 2021.01.22
boj 17124 두 개의 배열  (0) 2021.01.22

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

 

2805번: 나무 자르기

첫째 줄에 나무의 수 N과 상근이가 집으로 가져가려고 하는 나무의 길이 M이 주어진다. (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000) 둘째 줄에는 나무의 높이가 주어진다. 나무의 높이의 합은 항상 M보

www.acmicpc.net

잘려진 나무의 길이를 적어도 M으로 하기위한 높이의 최댓값을 구하는 문제입니다.

최적의 값을 구하는 문제이기때문에 이분탐색 중에서 파라매트릭 서치를 이용하여 해결할 수 있습니다.

 

높이를 1~list중 최대로 설정하여 파라매트릭 서치를 돌리고

잘려진 나무의 높이의 합이 M보다 작으면 l ~ m-1

잘려진 나무의 높이의 합이 M보다 크거나 같으면 m+1~r

로 높이를 재설정하여 구하면 됩니다.

 

최적의 값을 구해야하기 때문에 합이 M이라고 해서 바로 리턴해버리는 실수가 없어야합니다.

(합이 M이 나오지 않는 입력도 주어질 수 있습니다.)

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int list[];
    static int N, M, maxheight;
    static long ans = 0;
 
    static void binarysearch(long l, long r) {
        if (l > r)
            return;
 
        long m = (l + r) / 2;
        long sum = 0;
        for (int i = 1; i <= N; i++) {
            if (list[i] <= m)
                continue;
            sum += (list[i] - m);
        }
 
        if (sum >= M) {
            ans = Math.max(ans, m);
            binarysearch(m + 1, r);
        } else {
            binarysearch(l, m - 1);
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        list = new int[N + 1];
 
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            list[i] = Integer.parseInt(st.nextToken());
            maxheight = Math.max(maxheight, list[i]);
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        binarysearch(1, maxheight);
        System.out.println(ans);
    }
}
cs

'algorithm > binarysearch' 카테고리의 다른 글

boj 2110 공유기 설치  (0) 2021.04.13
boj 7453 합이 0인 네 정수  (0) 2021.01.22
boj 2143 두 배열의 합  (0) 2021.01.22
boj 1920 수 찾기  (0) 2021.01.22
boj 17124 두 개의 배열  (0) 2021.01.22

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

 

1920번: 수 찾기

첫째 줄에 자연수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 N개의 정수 A[1], A[2], …, A[N]이 주어진다. 다음 줄에는 M(1 ≤ M ≤ 100,000)이 주어진다. 다음 줄에는 M개의 수들이 주어지는데, 이 수들

www.acmicpc.net

가장 기본적인 이분탐색 알고리즘으로 해결 가능한 문제입니다.

 

주의할 점은 처음에 주어지는 배열의 크기인 N과

수가 배열안에 존재하는지 확인하는 배열의 크기인 M

둘의 크기가 다르다는 것입니다..

 

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int list[];
    static int ques[];
    static int N, M;
 
    static int binarysearch(int l, int r, int x) {
        if (l > r)
            return 0;
 
        int m = (l + r) / 2;
        if (list[m] == x)
            return 1;
        else {
            if (list[m] > x)
                return binarysearch(l, m - 1, x);
            else
                return binarysearch(m + 1, r, x);
        }
    }
 
    static void func() {
        for (int i = 1; i <= M; i++) {
            System.out.println(binarysearch(1, N, ques[i]));
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        list = new int[N + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            list[i] = Integer.parseInt(st.nextToken());
        }
        Arrays.sort(list);
 
        st = new StringTokenizer(br.readLine());
        M = Integer.parseInt(st.nextToken());
        ques = new int[M + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= M; i++) {
            ques[i] = Integer.parseInt(st.nextToken());
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

'algorithm > binarysearch' 카테고리의 다른 글

boj 2110 공유기 설치  (0) 2021.04.13
boj 7453 합이 0인 네 정수  (0) 2021.01.22
boj 2143 두 배열의 합  (0) 2021.01.22
boj 2805 나무 자르기  (0) 2021.01.22
boj 17124 두 개의 배열  (0) 2021.01.22

 

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

 

17124번: 두 개의 배열

정수 배열 A 와 B가 있다. A는 총 n개의 서로 다른 양의 정수를 포함하고 B는 총 m개의 서로 다른 양의 정수를 포함한다. A, B를 이용해서 길이가 n인 새로운 배열 C를 만들어보자. C[i] 는 배열 B에 있

www.acmicpc.net

C[i]는 배열 B에 있는 값 중에 A[i]에 가장 가까운 값이고 가장 가까운 값이 2개면 더 작은값입니다.

배열의 크기가 100만이므로 선형으로 찾기에는 무조건 시간초과이므로 이분탐색을 사용합니다.

(이분탐색을 위해 B 배열을 정렬해줍니다.)

 

A[i]가 주어지면

B 배열에서 A[i]보다 작은 값중에 가장 큰 값 = l

B 배열에서 A[i]보다 큰 값중에 가장 작은 값 = r

이러면 l과 r 둘중에 하나는 정답입니다.

 

abs(A[i] - l) vs abs(A[i] - r)를 비교하여 차이가 적은 값 (차이가 같으면 둘 중에 작은 값) 을 ans에 더해줍니다.

배열에 10^9까지 올 수 있으므로 long long 타입으로 계산하였습니다.

 

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
#include <iostream>
#include <algorithm>
#define INF 1000000000
using namespace std;
typedef long long ll;
 
int A[1000001], B[1000001];
int N, M;
ll ans;
 
int largesearch(int l, int r, int x) {
    int m = (l + r) / 2;
 
    if (B[m] == x) return B[m];
    else if (B[m] > x) {
        if (l == m) return B[m];
        else return min(B[m], largesearch(l, m - 1, x));
    }
    else {
        if (m == r) return INF;
        else return largesearch(m + 1, r, x);
    }
}
 
int smallsearch(int l, int r, int x) {
    int m = (l + r) / 2;
 
    if (B[m] == x) return B[m];
    else if (B[m] < x) {
        if (m == r) return B[m];
        else return max(B[m], smallsearch(m + 1, r, x));
    }
    else {
        if (l == m) return -1;
        else return smallsearch(l, m - 1, x);
    }
}
 
void func() {
    int l = 0, r = 0;
    for (int i = 1; i <= N; i++) {
        l = smallsearch(1, M, A[i]);
        r = largesearch(1, M, A[i]);
        if (l == -1) l = B[1];
        if (r == -1) r = B[M];
 
        if (abs(A[i] - l) <= abs(r - A[i])) {
            ans += l;
        }
        else ans += r;
    }
    cout << ans << '\n';
}
 
void input() {
    cin >> N >> M;
    for (int i = 1; i <= N; i++) {
        cin >> A[i];
    }
 
    for (int i = 1; i <= M; i++) {
        cin >> B[i];
    }
    sort(B + 1, B + 1 + M);
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    int tc;
    cin >> tc;
    while (tc--) {
        input();
        func();
        ans = 0;
    }
 
    return 0;
}
cs

'algorithm > binarysearch' 카테고리의 다른 글

boj 2110 공유기 설치  (0) 2021.04.13
boj 7453 합이 0인 네 정수  (0) 2021.01.22
boj 2143 두 배열의 합  (0) 2021.01.22
boj 2805 나무 자르기  (0) 2021.01.22
boj 1920 수 찾기  (0) 2021.01.22

+ Recent posts