public class MaxFlow {
    private static final int INF = Integer.MAX_VALUE;
 
    public static int maxFlow(int[][] cap, int s, int t) {
        int n = cap.length;
        int[][] flow = new int[n][n];
        int[] parent = new int[n];
        
        int maxFlow = 0;
        while (bfs(cap, flow, s, t, parent)) {
            int pathFlow = INF;
            for (int v = t; v != s; v = parent[v])
                pathFlow = Math.min(pathFlow, cap[parent[v]][v] - flow[parent[v]

fun maxFlow(cap: Array<IntArray>, s: Int, t: Int): Int {
    val n = cap.size
    val flow = Array(n) { IntArray(n) }
    val parent = IntArray(n)
    var maxFlow = 0
 
    while (bfs(cap, flow, s, t, parent)) {
        var pathFlow = Int.MAX_VALUE
        for (v in t downTo s) {
            pathFlow = minOf(pathFlow, cap[parent[v]][v] - flow[parent[v]][v])
        }
 
        for (v in t downTo s) {
            flow[parent[v]][v] += pathFlow
            flow[v][parent[v]] -= pathFlow
        }
 
        maxFlow += pathFlow
    }
 
    return maxFlow
}
 
private fun bfs(cap: Array<IntArray>, flow: Array<IntArray>, s: Int, t: Int, parent: IntArray): Boolean {
    val n = cap.size
    val visited = BooleanArray(n)
    val q = LinkedList<Int>()
 
    q.offer(s)
    visited[s] = true
    parent[s] = -1
 
    while (q.isNotEmpty()) {
        val u = q.poll()
        for (v in 0 until n) {
            if (!visited[v] && cap[u][v] - flow[u][v] > 0) {
                q.offer(v)
                visited[v] = true
                parent[v] = u
            }
        }
    }
 
    return visited[t]
}

// 최대 유량 알고리즘 구현
fun maxFlow(cap: Array<IntArray>, s: Int, t: Int): Int {
    // 네트워크의 크기
    val n = cap.size
    // 현재 유량 배열
    val flow = Array(n) { IntArray(n) }
    // 경로 추적을 위한 부모 배열
    val parent = IntArray(n)
    // 최대 유량
    var maxFlow = 0
 
    // 증가 경로를 찾을 때까지 반복
    while (bfs(cap, flow, s, t, parent)) {
        // 증가 경로의 최소 유량
        var pathFlow = Int.MAX_VALUE
        // 증가 경로 역추적
        for (v in t downTo s) {
            pathFlow = minOf(pathFlow, cap[parent[v]][v] - flow[parent[v]][v])
        }
        // 증가 경로의 유량 업데이트
        for (v in t downTo s) {
            flow[parent[v]][v] += pathFlow
            flow[v][parent[v]] -= pathFlow
        }
        // 최대 유량 업데이트
        maxFlow += pathFlow
    }
 
    return maxFlow
}
 
// 너비 우선 탐색을 이용한 증가 경로 찾기
private fun bfs(cap: Array<IntArray>, flow: Array<IntArray>, s: Int, t: Int, parent: IntArray): Boolean {
    // 네트워크의 크기
    val n = cap.size
    // 방문 여부 배열
    val visited = BooleanArray(n)
    // 큐
    val q = LinkedList<Int>()
 
    // 시작점 s 부터 탐색 시작
    q.offer(s)
    visited[s] = true
    parent[s] = -1
 
    // 큐가 빌 때까지 탐색
    while (q.isNotEmpty()) {
        val u = q.poll()
        // 모든 노드 v 에 대해 탐색
        for (v in 0 until n) {
            // 아직 방문하지 않았고, 잔여 용량이 있는 경우
            if (!visited[v] && cap[u][v] - flow[u][v] > 0) {
                // 큐에 추가하고 방문 표시, 부모 노드 기록
                q.offer(v)
                visited[v] = true
                parent[v] = u
            }
        }
    }
 
    // 싱크 노드 t 에 도달했는지 여부 반환
    return visited[t]
}
```여기는 문제들에 대한 한국어 번역입니다. 코드 부분은 번역하지 않고 주석만 번역했습니다.
 
우리는 N-body 시뮬레이션과 수치 선형 대수와 같은 과학 컴퓨팅 응용 프로그램부터 시작했습니다. 이러한 응용 프로그램은 대규모 계산을 처리하기 위해 효율적인 알고리즘에 의존합니다. 그런 다음 우리는 여행 판매원 문제와 네트워크 흐름 최적화와 같은 운영 연구 문제를 살펴보았습니다. 여기서 알고리즘 기술은 최적 또는 준최적 솔루션을 찾는 데 중요한 역할을 합니다.
 
다음으로 우리는 컴퓨터 그래픽, CAD, 지리 정보 시스템, 로봇공학 등 다양한 분야에서 발생하는 볼록 껍질, 가장 가까운 쌍, 선분 교차와 같은 기본적인 문제를 다루는 계산 기하학에 대해 살펴보았습니다. 이러한 문제를 실용적으로 해결하기 위해서는 효율적인 알고리즘이 필수적입니다.
 
마지막으로 텍스트 처리, 생물정보학, 네트워크 최적화 등에 중요한 응용 분야를 가진 접미사 배열과 최대 흐름 알고리즘과 같은 특수한 데이터 구조를 소개했습니다. 이러한 예는 특정 문제 영역에서 맞춤형 알고리즘 솔루션이 어떻게 상당한 성능 향상을 제공할 수 있는지 보여줍니다.
 
이 장에서 우리는 이론적 기반과 실용적 응용 사이의 상호작용을 강조했습니다. 기본 원리와 기술을 이해함으로써 우리는 복잡한 문제에 대한 효율적인 솔루션을 개발하고 새로운 상황에 적용할 수 있습니다.
 
알고리즘 학습을 계속하면서 이러한 기술이 적용되는 broader context를 염두에 두세요. 이 장에서 다룬 예는 알고리즘 문제 해결의 광범위한 영역 중 일부에 불과합니다. 기본 개념을 숙달하고 응용 분야를 탐구함으로써 오늘날과 미래의 컴퓨팅 과제에 대처할 수 있을 것입니다.