개인용 뇌 도서관

자바 알고리즘 부분집합 구하는 방법 CheetSheet

nomoreFt — Wed, 18 Oct 2023 09:53:38 +0900

1. 재귀함수

public static void dfs(int idx,int sum) {
    if(idx >= N){
        if(sum == S) result++;
        return;
    }

    dfs(idx + 1,  sum + arr[idx]);
    dfs(idx + 1,  sum);
}

고르고 안고른 1/2 의 모든 부분집합을 따져본 방법이다. [1,2,3,4]가 있을 경우,

1 2 3 4

(O,X) (O,X) (O,X) (O,X) 의 경우를 생각해서 고른 경우와 안고른 경우를 생각해보면 된다.

public static void dfs(int[] array, int idx, int choiceCnt, String result, int K){
	if(choiceCnt == 6){
    		System.out.println(result);
            return;
        }


    if(idx >= K) return;
    dfs(array, idx + 1, choiceCnt+1, result+array[idx]+" ",K);
    dfs(array, idx + 1, choiceCnt, result,K);
    }

특정 개수에 대한 제한을 걸면 위와 같아지는데, 고르고 안고른 모든 경우를 따지게 될 때, 특정 개수조건이 충족되면 작업을 수행하고 return 하면 된다. choiceCnt로 몇 개까지 O로 담아놨는지를 체크하는 로직만 추가된다.

또한 idx가 끝까지 도달했는데 6개를 담지 못했다면 나가리 처리한다.

2. 비트

for (int bit = 1; bit < (1 << N); bit++) {
    int sum = 0;
    for (int k = 0; k < N; k++) {
        if((bit & (1 << k)) != 0) {
            sum += arr[k];
        }
    }
    if( sum == S) {
        result++;
    }
}

bit가 1부터 시작하는 이유는 빈 수열을 나타내는 경우가 `bit=0`일 때입니다. 빈 수열의 합은 0이므로, 이를 제외하기 위해 `bit`를 1부터 시작하게 됩니다. 그래서 1부터 `1 << N`까지 반복문을 돌리는 것이죠.

더 깊게 들어가보면, `N`개의 원소가 있는 배열에서 만들 수 있는 모든 부분수열은 `2^N`개입니다. 그 중 빈 부분수열 1개를 제외한 나머지 `2^N - 1`개의 부분수열을 확인하는 것입니다. 그래서 `bit`를 1부터 시작해서 `1 << N`까지 반복문을 돌립니다. 이렇게 하면 빈 부분수열을 자연스럽게 제외할 수 있습니다.

쉽게 설명하자면, 4개의 배열이 있을 때, 선택과 선택하지 않음을 bit (1,0)으로 구분하고, 그 경우의 수를 구하면 2^N이 됩니다. (OOOO 다 고름, OXOX 2개만 고름) 거기서 4번째 for문에서 4 자리중 불이 켜진 곳이 어딘지 파악해서 원하는 경우를 구하면 됩니다.

[등차수열] 백준 등차수열 변환 - 17088

nomoreFt — Sat, 22 Jul 2023 16:12:35 +0900

[Gold V] 등차수열 변환 - 17088

문제 링크

성능 요약

메모리: 27856 KB, 시간: 336 ms

분류

브루트포스 알고리즘, 수학

문제 설명

크기가 N인 수열 A = [A1, A2, ..., AN]이 있을 때, 모든 1 ≤ i < N에 대해서, Ai+1-Ai가 모두 일치하면 등차수열이라고 한다. 예를 들어, [3], [6, 6, 6], [2, 8, 14, 20], [6, 4, 2]는 등차수열이고, [4, 5, 4], [6, 3, 1]은 등차수열이 아니다.

수열 B = [B1, B2, ..., BN]을 등차수열로 변환하려고 한다. 각각의 수에는 연산을 최대 한 번 적용할 수 있다. 연산은 두 가지가 있는데, 1을 더하거나 1을 빼는 것이다. 수열 B를 등차수열로 변환하기 위해 필요한 연산 횟수의 최솟값을 구해보자.

입력

첫째 줄에 수열 B의 크기 N(1 ≤ N ≤ 105)이 주어진다. 둘째 줄에는 B1, B2, ..., BN(1 ≤ Bi ≤ 109)이 주어진다.

출력

수열 B를 등차수열로 변화시키기 위한 연산 횟수의 최솟값을 출력한다. 등차수열로 변환시킬 수 없다면 -1을 출력한다.

분석

등차수열의 특징을 이용해야 하는 수학 문제다.

등차수열 : 연속하는 두 항의 차이가 모두 일정한 수열

공차를 선정해서 0번째 인덱스부터 공차를 더해 N번까지 가는데 등차에 해당하는 모든 경우를 따져보면 된다.
처음에는 문제에서 요구하는 `연산` 이 1을 더하거나 빼는 것이라는 것을 체크하지 못했는데 경우의 수를 줄이는 주요한 포인트이다.
문제에서 0, 1번째에서 생성가능한 등차의 경우를 구해서 나머지 모든 경우 O(N) 에서 적용해보면 된다.
생성 가능한 등차는 `연산 방법`에 따라 (0번째에 +1, -1, 가만히 둔 경우) * (1번째에 +1, -1, 가만히 둔 경우) = 9가지


* 첫 번째 항 -1, 두 번째 항 -1
* 첫 번째 항 -1, 두 번째 항 0
* 첫 번째 항 -1, 두 번째 항 +1
* 첫 번째 항 0, 두 번째 항 -1
* 첫 번째 항 0, 두 번째 항 0
* 첫 번째 항 0, 두 번째 항 +1
* 첫 번째 항 +1, 두 번째 항 -1
* 첫 번째 항 +1, 두 번째 항 0
* 첫 번째 항 +1, 두 번째 항 +1

공차를 구했다면 Array를 순회하면서 0번째부터 등차를 더한 값과 연산을 하여 해당 인덱스 값이 같아질 수 있는지 체크하면 된다.

시간 복잡도는 O(N) 100000 * 9(등차의 경우)라서 900000. 1초 안에 가능하다.

코드

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


public class Main {

    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());
        int[] arr = Arrays.stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt)
                .toArray();

        if (N == 1) {
            System.out.println(0);
            System.exit(0);
        }

        int ans = -1;

        for (int i = -1; i <= 1; i++) {
            for (int j = -1; j <= 1; j++) {
                int change = 0;
                if(i != 0) change++;
                if(j != 0) change++;
                int num1 = arr[1] + i;
                int num0 = arr[0] + j;

                //합의된 등차
                int diff = num1 - num0;

                boolean ok = true;
                int target = num0 + diff; //[0]번 + 선택한 등차 = [1]번
                for (int k = 2; k < N; k++) {
                    target += diff; // [1]번 + 등차 = 2번 이후 계속 진행

                    if (arr[k] + 1 == target) {
                        change++;
                    } else if (arr[k] - 1 == target) {
                        change++;
                    } else if (arr[k] == target) {
                        continue;
                    }else{
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    if (ans == -1 || ans > change) {
                        ans = change;
                    }
                }
            }
        }
        System.out.println(ans);

    }
}

Java 9 ~ 17까지 도입할만한 유용한 기능과 예시

nomoreFt — Thu, 20 Jul 2023 16:32:40 +0900

Java 9

인터페이스의 private 메소드: 인터페이스에서도 private 메소드를 선언할 수 있게 되었습니다. 이를 통해 코드의 재사용성을 높일 수 있습니다.
- 메소드 구현의 세부 사항 숨기기: private 메소드는 인터페이스 외부에서는 접근할 수 없으므로, 메소드의 구현 세부 사항을 숨기고 추상화 수준을 높일 수 있습니다. 이는 캡슐화 원칙을 더 잘 지키는 데 도움이 됩니다.
- 인터페이스의 안정성 향상: private 메소드는 인터페이스의 공개 API의 일부가 아니므로, 이를 변경하더라도 인터페이스를 구현하는 클래스들에게 영향을 미치지 않습니다. 따라서 인터페이스의 안정성을 향상시키는 데 도움이 됩니다.

public interface MyInterface {
    default void myMethod() {
        helperMethod();
    }

    private void helperMethod() {
        System.out.println("Helper method in interface");
    }
}

Java 10

지역 변수의 타입 추론(var): 자료형을 명시하지 않아도, 컴파일러가 변수의 타입을 추론할 수 있게 해줍니다.

// Old way
String name = "John";

// New way
var name = "John";

Java 11

String의 새로운 메소드들: String 클래스에는 isBlank(), lines(), strip(), repeat() 등 새로운 메소드들이 추가되었습니다.

var name = "  John  ";

// Using new methods
System.out.println(name.isBlank());       // false
System.out.println(name.strip());         // "John"
System.out.println(name.repeat(2));       // "  John    John  "

Predicate.not 이 생겼습니다. filter시에 부정문으로 제끼기 더 편해졌네요.

List<String> myList = Arrays.asList("Like,"  ", "Subscribe");
List<String> withoutBlanks = myList.stream()
                            .filter(Predicate.not(String::isBlank))
                            .collect(Collectors.toList());

toArray 메서드가 생겼습니다.


List<String> list = Arrays.asList("Like","and","Piece");
String[] array = list.toArray(String[]::new);

List의 CopyOf, Collectors.toUnmodifiableList 메서드가 생겼습니다.

List<String> modifiableList = new ArrayList<>();
modifiableList.add("foo");
modifiableList.add("bar");

List<String> unmodifiableList = List.copyOf(modifiableList);

// 이 코드는 UnsupportedOperationException을 던집니다.
unmodifiableList.add("baz");


---------------------------------------------------

List<String> list = Stream.of("apple", "banana", "cherry")
                                  .collect(Collectors.toUnmodifiableList());

System.out.println(list);

// UnsupportedOperationException을 발생시킵니다.
list.add("orange");

불변 리스트의 장점
- 외부 코드에 리스트를 전달할 때: unmodifiableList를 사용하면 외부 코드가 리스트를 변경하는 것을 막을 수 있습니다.
- 멀티스레드 환경에서 리스트를 공유할 때: unmodifiableList를 사용하면 여러 스레드가 동시에 리스트를 변경하는 것을 방지할 수 있습니다.

writeStirng , readString File을 String으로 처리할 수 있게 되었습니다.

String file = "java11.txt"
Files.writeString(Paths.get(file), "Geekific", StandardOpenOption.CREATE);
String content = Files.readString(Paths.get(file));
System.out.println(content);

Java 12

Switch Expressions: switch 문이 표현식으로 사용될 수 있게 되었으며, yield 키워드를 사용하여 값을 반환할 수 있게 되었습니다.

// Old way
String day = "MONDAY";
switch (day) {
    case "MONDAY":
        System.out.println("It's Monday");
        break;
    // ... and so on
}

// New way
String day = "MONDAY";
switch (day) {
    case "MONDAY" -> System.out.println("It's Monday");
    // ... and so on
}

Java 13

텍스트 블록(Text Blocks): 세 개의 큰 따옴표(""")를 사용하여 멀티 라인 문자열을 표현할 수 있게 되었습니다.


String text = """
              Hello,
              World
              """;

Java 14

instanceof 패턴 매칭: instanceof 연산자가 패턴 매칭을 지원하게 되어, 캐스팅 없이 조건문을 사용할 수 있게 되었습니다.


//이전
Person person = new Employee();
if(person instanceof Employee) {
    Employee employee = (Employee) person;
    //형변환 하고 할일 진행
}

//발전

if(person instanceof Employee employee && employee.getYearsOfService() > 5){
//    employee로 바로 Employee 할 일 진행
}

Java 15

Sealed Classes: 클래스 또는 인터페이스를 특정 타입들에게만 상속 또는 구현을 허용하도록 제한할 수 있게 되었습니다.

public sealed interface Shape permits Circle, Rectangle {
    // ...
}

public final class Circle implements Shape {
    // ...
}

public non-sealed class Rectangle implements Shape {
    // ...
}

Java 16

Records: 클래스의 필드, 생성자, getter, equals(), hashCode(), toString() 등을 자동으로 생성해주는 기능입니다. DTO 나 OpenAPI에서 받아오는 Response 객체 등을 담을 때 유용할 것 같습니다.

record Point(int x, int y) { }

Java 17

String indent 메서드. 들여쓰기가 편해집니다.

String text = "test!!!!"
text = text.indent(4); // "    test!!!!"
text = text.indent(-2); // "  test!!!!"

String transform 메서드. 파라미터 자를때 유용하게 쓸 수 있을 것 같습니다.

"test!@#$".transform(value ->
            new StringBuilder(value).delete(4,7).toString());

            //test 반환

Collectors.teeing 메서드

public static <T,A1,R1,A2,R2,R> Collector<T,?,R> teeing(
    Collector<? super T,A1,R1> downstream1,
    Collector<? super T,A2,R2> downstream2,
    BiFunction<? super R1,? super R2,R> merger
)

* downstream1과 downstream2는 두 개의 다운스트림 컬렉터입니다.
* merger는 두 다운스트림 결과를 결합하는 함수입니다.

사용 예시

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        Integer range = numbers.stream()
                .collect(Collectors.teeing(
                        Collectors.minBy(Integer::compareTo),
                        Collectors.maxBy(Integer::compareTo),
                        (min, max) -> max.orElse(0) - min.orElse(0)
                ));

        System.out.println("Range: " + range);

코틀린 vs 자바

nomoreFt — Tue, 18 Jul 2023 18:09:05 +0900

자바가 있는데 굳이 코틀린을 배워야해? 라고 생각한 뒤, 생각을 고쳐먹고 최근 코틀린을 배우기로 생각했습니다.
그래서 코틀린이 자바보다 좋은 이유들을 찾고 있습니다.그것에 대한 정리글입니다.

간결한 문법: Kotlin은 더 간결한 문법을 제공하여 코드를 더 간결하게 작성할 수 있습니다. 예를 들어, Nullable 타입, 확장 함수, 데이터 클래스 등의 기능을 활용하여 코드를 더 간단하고 명확하게 작성할 수 있습니다.
```
// Java 코드
 String name = "John";
 if (name != null) {
     System.out.println(name.toUpperCase());
 }

 // Kotlin 코드
 val name: String? = "John"
 println(name?.toUpperCase())
```

Null 안전성: Kotlin은 타입 시스템에서 Nullable 타입과 Non-Nullable 타입을 명확하게 지원하여 Null 포인터 예외를 방지하는 데 도움을 줍니다. 이로 인해 Null 관련 버그를 줄일 수 있고, 코드의 안정성을 향상시킬 수 있습니다.
```
// Java 코드
 String name = null;
 System.out.println(name.length()); // NullPointerException 발생

 // Kotlin 코드
 val name: String? = null
 println(name?.length) // null 출력
```

확장 함수: Kotlin은 확장 함수를 지원하여 기존 클래스의 기능을 확장할 수 있습니다. 이는 기존 클래스의 코드 수정 없이 새로운 함수를 추가할 수 있는 장점을 제공합니다.
```
// Java 코드
 StringUtils.capitalize("hello"); // 외부 클래스의 정적 메서드 호출

 // Kotlin 코드
 "hello".capitalize() // String 클래스에 capitalize() 함수 추가
```

함수형 프로그래밍 지원: Kotlin은 함수형 프로그래밍의 개념과 기능을 지원합니다. 람다 식, 고차 함수, 스트림 처리 등을 활용하여 코드를 더욱 간결하고 효율적으로 작성할 수 있습니다.

// Java 코드
 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
 int sum = 0;
 for (int num : numbers) {
     sum += num;
 }
 System.out.println(sum);

 // Kotlin 코드
 val numbers = listOf(1, 2, 3, 4, 5)
 val sum = numbers.sum()
 println(sum)

자바 호환성: Kotlin은 100% 자바와 상호 운용이 가능합니다. 기존의 자바 코드와 라이브러리를 Kotlin으로 전환하거나 Kotlin 코드를 자바와 함께 사용하는 것이 매우 쉽습니다. 이는 기존 자바 프로젝트에서 점진적으로 Kotlin을 도입할 수 있음을 의미합니다.

위의 예시 코드에서 볼 수 있듯이, Kotlin은 코드를 더 간결하고 안전하게 작성할 수 있도록 도와줍니다. 이를 통해 생산성을 향상시키고 버그를 줄이는 데 도움이 됩니다. 또한, Kotlin은 Java와의 상호 운용성을 제공하여 기존 자바 코드와 라이브러리를 쉽게 활용할 수 있습니다.

알고리즘에서 비트마스크로 경우의 수 따지는 방법

nomoreFt — Tue, 18 Jul 2023 18:00:46 +0900

때로 브루트포스에서 경우의 수 (부분집합)를 따지는 상황이 왕왕 발생한다.

그런 상황에서 요긴하게 쓰이는 bitmask로 경우의 수 따지기, 유용한 상황 처리에 대해서 정리하려고 한다.

비트마스크(Bitmask)는?

이진수로 표현된 비트들의 집합으로, 각 비트가 특정 상태를 나타냅니다. 비트마스크를 사용하면 집합의 부분집합을 효과적으로 나타낼 수 있고, 이를 활용하여 경우의 수를 따질 수 있습니다.

기본적인 사용법

public class BitmaskExample {
    public static void main(String[] args) {
        int n = 3; // 비트 수
        int total = 1 << n; // 총 경우의 수: 2^n

        for (int i = 0; i < total; i++) {
            for (int j = 0; j < n; j++) {
                if ((i & (1 << j)) > 0) {
                    // j번째 비트가 1인 경우의 처리
                    System.out.print(1);
                } else {
                    // j번째 비트가 0인 경우의 처리
                    System.out.print(0);
                }
            }
            System.out.println(); // 한 줄 출력 후 개행
        }
    }
}

1.각 비트를 사용, 사용X의 상태로 생각 :

예를들어 int[] A = {1,2,3} 이라면 123의 부분집합을 구하여 문제에서 주어진 경우의 수를 따질 수 있다.

-> 예를 들어 3개의 비트를 사용한다면, 000,001,010,011,100,101,110,111 과 같이 2^3 = 8가지의 상태를 나타낼 수 있다.

2. 비트 연산을 통한 조합 :

비트 연산을 사용해 특정 경우가 사용되고 있는지, 내가 원하는 비트가 켜져 있는지 체크하여 경우의 수를 고려할 수 있다.

-> & (AND), | (OR), ^(XOR) , ~ (NOT) 연산을 사용한다.

예시

괄호 추가하기 : https://www.acmicpc.net/problem/16637

괄호 추가하기의 문제로 3+87-92 식의 수식이 주어지면 연속된 괄호 없이 모든 괄호를 치는 '경우의 수' 를 따져서 최대 계산 값을 따지는 문제이다.

이 문제에서는 괄호가 연속으로 쳐지면 안된다. 따라서 우리는 비트마스크를 사용하여 괄호를 적용할 위치의 부분집합을 나타내고, 이를 통해 가능한 모든 경우의 수를 구하게 된다.

다음과 같은 경우를 예로 들어보겠습니다:

(3+8)(7-9)2 의 경우는 가능
((3+8)7)-92 의 경우 불가능. 중첩 괄호 X


        int cnt = 수식의 수 4


//(+ , *, -, * ) 의 부분집합들로 모든 경우의 수를 찾는다.
        for (int bit = 0; bit < (1 << cnt); bit++) {
            boolean ok = true;

        //각 경우마다 내부에서 0,1,2,3번째 개체가 들어갔나 체크하기 위해 반복한다.
            for(int i = 0; i < m - 1; i++) {
                //지금 부분집합 (bit) 에서 지금과 다음 수식에 괄호가 함께 쓰이면 패스한다.
                if((bit & (1 << i)) > 0 && (bit & (1 << (i + 1))) > 0) {
                    ok = false;
                    break;
                }
            }
            if(!ok) continue;

            //하고 싶은 작업

         }

Java 코드에서는 먼저 수식의 개수를 기반으로 부분집합을 나타내는 bit를 설정합니다.
이후 모든 부분집합에 대해, 연속된 두 수식에 동시에 괄호가 적용되어 있는지 검사합니다.
이 경우, 괄호가 연속해서 적용되어 있으므로 해당 부분집합은 배제하고, 그렇지 않은 경우에만 계산을 진행하게 됩니다.
이 방법을 통해 연속된 괄호 없이 모든 괄호를 적용할 수 있는 경우의 수를 구할 수 있습니다.

Java에서 효율적인 경우의 수 따지기

nomoreFt — Fri, 14 Jul 2023 15:25:15 +0900

C++의 next_permutation 구현

static boolean next_permutation(int[] a) {
        int i = a.length-1;
        while (i > 0 && a[i-1] >= a[i]) {
            i -= 1;
        }

        if (i <= 0) {
            return false;
        }

        int j = a.length-1;
        while (a[j] <= a[i-1]) {
            j -= 1;
        }

        int temp = a[i-1];
        a[i-1] = a[j];
        a[j] = temp;

        j = a.length-1;
        while (i < j) {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            i += 1;
            j -= 1;
        }
        return true;
    }

실사용 예시

경우의 수를 구하고 싶은 List의 숫자만큼 d[i] 로 Array를 구현한 다음, 해당 d[i] 를 next_permutation 돌린다.
do-while로 nextPermuation을 사용하는 모습. bitMask를 구현한 것과 같다

        int[] d = new int[store.size()];
        for (int i=0; i<m; i++) {
            d[i] = 1;
        }
        Arrays.sort(d);
        int ans = -1;
        do {
            int sum = 0;
            for (Pair p : people) {
                int min = -1;
                for (int i=0; i<store.size(); i++) {
                    if (d[i] == 0) continue;
                    Pair s = store.get(i);
                    int d1 = p.first-s.first;
                    int d2 = p.second-s.second;
                    if (d1 < 0) d1 = -d1;
                    if (d2 < 0) d2 = -d2;
                    int dist = d1+d2;
                    if (min == -1 || min > dist) {
                        min = dist;
                    }
                }
                sum += min; 
            }
            if (ans == -1 || ans > sum) {
                ans = sum;
            }
        } while (next_permutation(d));

`순열` 재귀함수 백트래킹으로 구현하기

제일 애용하는 방법. start index를 이용해서 경우의 수가 반복되지 않게 한방향으로 모든 순열의 경우를 구할 수 있다.

    static void go(int idx, String sum) {
        if (idx == n) {
            System.out.println(sum);
        }

        //전체 순열이라 매 숫자 Choice시에 전체 경우중 선택하지 않은 것 고려
        for(int i = 0; i < n; i++) {
            if(visited[i]) continue;
            //0으로 시작하는 숫자는 제외할 경우
            if(idx == 0 && A[i]== 0) continue;
            visited[i] = true;
            go( idx + 1, sum + A[i]);
            visited[i] = false;
        }
    }

보통 모든 경우의 수 중에서 특정 조건을 충족하는 것들을 추출해낼 때 사용한다.

`조합` 재귀함수 백트래킹으로 구현하기

public class Main {
    static int[] A = {1,2,3,4};
    static boolean visited[] = new boolean[4];
    public static void main(String[] args) {
        go(0,0,"");
    }

    private static void go(int idx, int start, String sum) {
        if (idx == 3) {
            System.out.println(sum);
            return;
        }

        for (int i = start; i < 4; i++) {
            if (visited[i]) continue;
            visited[i] = true;
            go(idx + 1, i + 1, sum + A[i]); // 현재 인덱스 다음부터 시작
            visited[i] = false;
        }
    }
}

로또같은 것들은 49개의 숫자중에서 중복되지 않게 6개를 골라야 하는 경우다. 모든 로또의 경우는 순열이 아니라 조합이다.

bit로 경우의 수 구하기

모든 부분집합을 구할 때 편하다.


public class Main {
    static int[] A = {1,2,3,4};
    static boolean visited[] = new boolean[4];
    public static void main(String[] args) {

        for (int bit = 0; bit < (1 << 4); bit++) {//2의 4승으로 4가지 배열의 모든 on/off를 고려
            String sum = "";
            for (int i = 0; i < 4; i++) {//각 비트 자리수를 확인 ( ㅇ ㅇ ㅇ ㅇ )
                if ((bit & (1 << i)) != 0) {//i번째 비트가 1이면 i번째 원소 출력
                    sum += A[i];
                }
            }
            System.out.println(sum);

        }
    }
}

bit로 부분집합 구하기

public class Main {
    static int[] A = {1,2,3,4};
    static boolean visited[] = new boolean[4];
    public static void main(String[] args) {

        for (int bit = 0; bit < (1 << 4); bit++) {//2의 4승으로 4가지 배열의 모든 on/off를 고려
            String sum = "";
            int cnt = 0;
            for (int i = 0; i < 4; i++) {//각 비트 자리수를 확인 ( ㅇ ㅇ ㅇ ㅇ )
                if ((bit & (1 << i)) != 0) {//i번째 비트가 1이면 i번째 원소 출력
                    cnt++;
                    sum += A[i];
                }
            }

            if(cnt == 2) System.out.println(sum);

        }
    }
}

알고리즘의 최우선 고려대상은 브루트포스 (전체 탐색) 으로 가능한지, 아닌지이다. 지금까지 경우의 수를 구하는 다양한 방법을 알아봤는데 이 경우의 수 틀에서 문제에 맞게 사용하면 된다.

`bit vs 재귀`

비트 연산을 사용한 방법과 재귀를 사용한 방법은 각각의 상황에서 장단점이 있을 수 있다. 지금의 경우, 4개의 원소에서 2개를 선택하는 조합을 구하는 상황이므로 성능 차이는 거의 나지 않을 것이다.

1. 비트 연산:
  장점: 코드가 간결하고, 직관적입니다.
  단점: 문제의 규모가 커지면 비트 연산을 사용할 수 없는 경우가 발생할 수 있습니다. (32비트나 64비트 제한 등)
1. 재귀 호출:
  장점: 문제의 규모가 커져도 유연하게 대처할 수 있으며, 더 복잡한 문제에도 적용할 수 있습니다.
  단점: 코드가 조금 더 복잡하고, 재귀 호출에 따른 오버헤드가 있을 수 있습니다.
  그럼에도 불구하고, 위와 같은 작은 문제에서는 두 방법 모두 거의 동일한 성능을 보일 것입니다. 어떤 방식을 사용할지는 주로 코드의 가독성, 유지보수성, 확장성 등을 고려하여 결정하게 됩니다.

때에 따라서는 두 가지 방식을 혼합해서 사용하는 것도 좋은 방법이 될 수 있으니, 문제의 특성과 요구사항에 맞게 선택하면 된다.

인접 리스트

nomoreFt — Fri, 14 Jul 2023 15:24:23 +0900

인접 행렬

nomoreFt — Fri, 14 Jul 2023 15:24:09 +0900

플로이드 와샬 알고리즘

nomoreFt — Fri, 14 Jul 2023 15:23:37 +0900

벨만 포드 알고리즘

nomoreFt — Fri, 14 Jul 2023 15:23:10 +0900