hardy

[ANDROID] MPAndroidChart Rounded Candle Stick Chart

hardy97 — Tue, 13 Jun 2023 11:20:22 +0900

MPAndroidChart Rounded Candle Stick Chart

canvas.drawRect -> canvas.drawRoundRect

import android.graphics.Canvas
import android.graphics.Paint
import com.github.mikephil.charting.animation.ChartAnimator
import com.github.mikephil.charting.interfaces.dataprovider.CandleDataProvider
import com.github.mikephil.charting.interfaces.datasets.ICandleDataSet
import com.github.mikephil.charting.renderer.CandleStickChartRenderer
import com.github.mikephil.charting.utils.ColorTemplate
import com.github.mikephil.charting.utils.ViewPortHandler

class CustomCandleStickChartRender(
    chart: CandleDataProvider,
    animator: ChartAnimator,
    viewPortHandler: ViewPortHandler
) : CandleStickChartRenderer(chart, animator, viewPortHandler) {
    private var mRadius: Int = 0

    private val mShadowBuffers = FloatArray(8)
    private val mBodyBuffers = FloatArray(4)
    private val mRangeBuffers = FloatArray(4)
    private val mOpenBuffers = FloatArray(4)
    private val mCloseBuffers = FloatArray(4)

    fun setRadius(mRadius: Int) {
        this.mRadius = mRadius
    }

    override fun drawDataSet(c: Canvas, dataSet: ICandleDataSet) {
        val trans = mChart.getTransformer(dataSet.axisDependency)

        val phaseY = mAnimator.phaseY
        val barSpace = dataSet.barSpace
        val showCandleBar = dataSet.showCandleBar

        mXBounds[mChart] = dataSet

        mRenderPaint.strokeWidth = dataSet.shadowWidth

        // draw the body

        // draw the body
        for (j in mXBounds.min..mXBounds.range + mXBounds.min) {

            // get the entry
            val e = dataSet.getEntryForIndex(j) ?: continue
            val xPos = e.x
            val open = e.open
            val close = e.close
            val high = e.high
            val low = e.low
            if (showCandleBar) {
                // calculate the shadow
                mShadowBuffers[0] = xPos
                mShadowBuffers[2] = xPos
                mShadowBuffers[4] = xPos
                mShadowBuffers[6] = xPos
                if (open > close) {
                    mShadowBuffers[1] = high * phaseY
                    mShadowBuffers[3] = open * phaseY
                    mShadowBuffers[5] = low * phaseY
                    mShadowBuffers[7] = close * phaseY
                } else if (open < close) {
                    mShadowBuffers[1] = high * phaseY
                    mShadowBuffers[3] = close * phaseY
                    mShadowBuffers[5] = low * phaseY
                    mShadowBuffers[7] = open * phaseY
                } else {
                    mShadowBuffers[1] = high * phaseY
                    mShadowBuffers[3] = open * phaseY
                    mShadowBuffers[5] = low * phaseY
                    mShadowBuffers[7] = mShadowBuffers[3]
                }
                trans.pointValuesToPixel(mShadowBuffers)

                // draw the shadows
                if (dataSet.shadowColorSameAsCandle) {
                    if (open > close) mRenderPaint.color =
                        if (dataSet.decreasingColor == ColorTemplate.COLOR_NONE) dataSet.getColor(j) else dataSet.decreasingColor else if (open < close) mRenderPaint.color =
                        if (dataSet.increasingColor == ColorTemplate.COLOR_NONE) dataSet.getColor(j) else dataSet.increasingColor else mRenderPaint.color =
                        if (dataSet.neutralColor == ColorTemplate.COLOR_NONE) dataSet.getColor(j) else dataSet.neutralColor
                } else {
                    mRenderPaint.color =
                        if (dataSet.shadowColor == ColorTemplate.COLOR_NONE) dataSet.getColor(j) else dataSet.shadowColor
                }
                mRenderPaint.style = Paint.Style.STROKE
                c.drawLines(mShadowBuffers, mRenderPaint)

                // calculate the body
                mBodyBuffers[0] = xPos - 0.5f + barSpace
                mBodyBuffers[1] = close * phaseY
                mBodyBuffers[2] = xPos + 0.5f - barSpace
                mBodyBuffers[3] = open * phaseY
                trans.pointValuesToPixel(mBodyBuffers)

                // draw body differently for increasing and decreasing entry
                if (open > close) { // decreasing
                    if (dataSet.decreasingColor == ColorTemplate.COLOR_NONE) {
                        mRenderPaint.color = dataSet.getColor(j)
                    } else {
                        mRenderPaint.color = dataSet.decreasingColor
                    }
                    mRenderPaint.style = dataSet.decreasingPaintStyle
                    c.drawRoundRect(
                        mBodyBuffers[0], mBodyBuffers[3],
                        mBodyBuffers[2], mBodyBuffers[1],
                        mRadius.toFloat(), mRadius.toFloat(),
                        mRenderPaint
                    )
                } else if (open < close) {
                    if (dataSet.increasingColor == ColorTemplate.COLOR_NONE) {
                        mRenderPaint.color = dataSet.getColor(j)
                    } else {
                        mRenderPaint.color = dataSet.increasingColor
                    }
                    mRenderPaint.style = dataSet.increasingPaintStyle
                    c.drawRoundRect(
                        mBodyBuffers[0], mBodyBuffers[1],
                        mBodyBuffers[2], mBodyBuffers[3],
                        mRadius.toFloat(), mRadius.toFloat(),
                        mRenderPaint
                    )
                } else { // equal values
                    if (dataSet.neutralColor == ColorTemplate.COLOR_NONE) {
                        mRenderPaint.color = dataSet.getColor(j)
                    } else {
                        mRenderPaint.color = dataSet.neutralColor
                    }
                    c.drawLine(
                        mBodyBuffers[0], mBodyBuffers[1],
                        mBodyBuffers[2], mBodyBuffers[3],
                        mRenderPaint
                    )
                }
            } else {
                mRangeBuffers[0] = xPos
                mRangeBuffers[1] = high * phaseY
                mRangeBuffers[2] = xPos
                mRangeBuffers[3] = low * phaseY
                mOpenBuffers[0] = xPos - 0.5f + barSpace
                mOpenBuffers[1] = open * phaseY
                mOpenBuffers[2] = xPos
                mOpenBuffers[3] = open * phaseY
                mCloseBuffers[0] = xPos + 0.5f - barSpace
                mCloseBuffers[1] = close * phaseY
                mCloseBuffers[2] = xPos
                mCloseBuffers[3] = close * phaseY
                trans.pointValuesToPixel(mRangeBuffers)
                trans.pointValuesToPixel(mOpenBuffers)
                trans.pointValuesToPixel(mCloseBuffers)

                // draw the ranges
                var barColor: Int
                barColor =
                    if (open > close) if (dataSet.decreasingColor == ColorTemplate.COLOR_NONE) dataSet.getColor(
                        j
                    ) else dataSet.decreasingColor else if (open < close) if (dataSet.increasingColor == ColorTemplate.COLOR_NONE) dataSet.getColor(
                        j
                    ) else dataSet.increasingColor else if (dataSet.neutralColor == ColorTemplate.COLOR_NONE) dataSet.getColor(
                        j
                    ) else dataSet.neutralColor
                mRenderPaint.color = barColor
                c.drawLine(
                    mRangeBuffers[0], mRangeBuffers[1],
                    mRangeBuffers[2], mRangeBuffers[3],
                    mRenderPaint
                )
                c.drawLine(
                    mOpenBuffers[0], mOpenBuffers[1],
                    mOpenBuffers[2], mOpenBuffers[3],
                    mRenderPaint
                )
                c.drawLine(
                    mCloseBuffers[0], mCloseBuffers[1],
                    mCloseBuffers[2], mCloseBuffers[3],
                    mRenderPaint
                )
            }
        }
    }
}

    private fun setCandleStickRadius() {
        val barChartRenderer = CustomCandleStickChartRender(
            viewDataBinding.chart,
            viewDataBinding.chart.animator,
            viewDataBinding.chart.viewPortHandler
        )
        barChartRenderer.setRadius(8)

        viewDataBinding.chart.renderer = barChartRenderer
    }

result

thinStick -> set

CandleDataSet.barSpace

[ANDORID] hilt를 왜 사용할까?

hardy97 — Fri, 23 Dec 2022 21:20:56 +0900

간단 정리

나는 hilt를 왜 사용할까?

먼저 hilt는 의존성 주입을 도와주는 라이브러리이다.

hilt의 장점은 의존성 주입의 장점이라고도 할 수 있다.

주입받는 대상이 변하더라도 주입되는 객체의 구현에는 변화가 없다. 즉, 재사용성이 좋다
의존성이 있는 객체를 찾기 쉽다. 즉, 가독성이 좋다
객체를 붙였다 떼었다 하기가 쉽기 때문에 프로젝트 변화에 유연성이 좋다.

dagger2나 Koin보다 hilt를 사용하는 이유는 다음과 같다.

	dagger2	koin	hilt
러닝커브	높다	낮다	낮다
error 시점	compile time	runtime	compile
java	O	X	O

배우기가 쉽고

error를 역 추적해야 하는 runtime에러보다 비교적 에러를 찾기 쉬운 compile time에 에러가 발생하고

자바를 지원한다.

[KOTLIN] 백준-2667번 단지번호붙이기

hardy97 — Thu, 22 Dec 2022 00:11:49 +0900

문제

<그림 1>과 같이 정사각형 모양의 지도가 있다. 1은 집이 있는 곳을, 0은 집이 없는 곳을 나타낸다. 철수는 이 지도를 가지고 연결된 집의 모임인 단지를 정의하고, 단지에 번호를 붙이려 한다. 여기서 연결되었다는 것은 어떤 집이 좌우, 혹은 아래위로 다른 집이 있는 경우를 말한다. 대각선상에 집이 있는 경우는 연결된 것이 아니다. <그림 2>는 <그림 1>을 단지별로 번호를 붙인 것이다. 지도를 입력하여 단지수를 출력하고, 각 단지에 속하는 집의 수를 오름차순으로 정렬하여 출력하는 프로그램을 작성하시오.

입력

첫 번째 줄에는 지도의 크기 N(정사각형이므로 가로와 세로의 크기는 같으며 5≤N≤25)이 입력되고, 그 다음 N줄에는 각각 N개의 자료(0혹은 1)가 입력된다.

출력

첫 번째 줄에는 총 단지수를 출력하시오. 그리고 각 단지내 집의 수를 오름차순으로 정렬하여 한 줄에 하나씩 출력하시오.

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

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val bw = BufferedWriter(OutputStreamWriter(System.out))

    var dx = arrayOf(0, 1, 0, -1)
    var dy = arrayOf(1, 0, -1, 0)

    val n = br.readLine().toInt()
    var board = Array(n, { Array(n, { 0 }) })
    var visited = Array(n, { Array(n, { false }) })

    var counts = mutableListOf<Int>()

    fun bfs(x: Int, y: Int) {
        visited[x][y] = true
        val q: Queue<Pair<Int, Int>> = LinkedList()
        q.add(Pair(x, y))
        var count = 1

        while (!q.isEmpty()) {
            val p = q.poll()
            repeat(4) { index ->
                val nextX = p.first + dx[index]
                val nextY = p.second + dy[index]
                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < n && !visited[nextX][nextY] && board[nextX][nextY] == 1) {
                    visited[nextX][nextY] = true
                    q.add(Pair(nextX, nextY))
                    count += 1
                }
            }
        }

        counts.add(count)
    }

    // 채우기
    repeat(n) { i ->
        val line = br.readLine()
        line.forEachIndexed { j, c ->
            board[i][j] = Character.getNumericValue(c)
        }
    }

    repeat(n) { i ->
        repeat(n) { j ->
            if (!visited[i][j] && board[i][j] == 1) {
                bfs(i, j)
            }
        }
    }

    counts.sort()

    bw.write("${counts.size}\n")
    counts.forEach { count ->
        bw.write("$count\n")
    }

    bw.flush()
    bw.close()
    br.close()
}

풀이

먼저 판을 채우고 모든 판을 검사한다. 만약 visited되지 않고 1인 곳이 있다면

bfs를 돌아 연결되어있는 판의 크기를 구한다. 이때 들릴때마다 visited 처리를 해서 한번 더 들리지 못하게 한다.

그리고 판의 크기들을 리스트에 채운뒤 정렬하여 출력한다.

[RxJava] RxJava에 대한 이해

hardy97 — Wed, 21 Dec 2022 21:16:35 +0900

Reactvie Programming?

Reactive Programming이란 데이터 흐름과 전달에 관한 프로그래밍 패러다임입니다.

우리는 주로 작성한 순서대로 실행되는 Imperative Programming(명령형 프로그래밍)을 한다. 반면 Reactive Programming이란 데이터의 흐름을 먼저 정의하고 데이터가 변경되었을 때 연관된 작업이 실행됩니다. 즉, 프로그래머가 어떠한 기능을 직접 호출해서 실행시키는 것이 아닌, 이벤트가 발생했을 때 알아서 처리되는 것이다.

기존의 프로그래밍 방식을 Pull 방식, Reactive 프로그래밍 방식을 Push 방식이라고도 합니다.
Pull 방식은 데이터를 사용하는 곳(Consumer)에서 데이터를 직접 가져와서 사용한다면,
Push 방식은 데이터의 변화가 발생한 곳에서 새로운 데이터를 Consumer에게 전달한다.

따라서 Reactive 프로그래밍은 주변 환경과 끊임없이 상호작용을 한다. 다만 프로그램이 주도하는 것이 아니라 환경이 변하면 이벤트를 받아 동작함으로써 상호작용한다.

RxJava

RxJava는 ReactiveX의 Java 언어 라이브러리로, 2013년 2월 넷플릭스에서 처음 소개하였다. 2016년 10월 RxJava2를 발표하였으며 2020년 2월 RxJava3를 배포했습니다.

ReactiveX는 관찰가능한 절차를 통해 비동기, 이벤트 기반 프로그램을 구성하기 위한 라이브러리이다.
Observer Pattern을 확장하며, Sequence를 조합할 수 있는 연산자를 지원한다.
low-level Thread, 동기화, Thread 안전성, non-blocking I/O에 관한 우려를 줄인다.

RxJava는 러닝 커브가 가파르다. 전통적인 스레드 기반의 프로그래밍을 사용하는 자바와 접근 방식이 다르기 때문이다. 여러 스레드를 사용하는 경우 예상치 못한 문제가 발생할 수도 있고 디버깅하기도 어렵다.

따라서 RxJava는 함수형 프로그래밍 방식을 도입하였다. 함수형 프로그래밍은 부수 효과가 없는 순수 함수를 지향하기 때문에 Thread-Safe하다.

ReactiveX의 이러한 방식을 구성하게 해주는 핵심 요소가 바로 Observable과 Operator(연산자)이다.

[KOTLIN] 백준-14886 연산자 끼워넣기

hardy97 — Tue, 20 Dec 2022 23:17:26 +0900

문제

N개의 수로 이루어진 수열 A1, A2, ..., AN이 주어진다. 또, 수와 수 사이에 끼워넣을 수 있는 N-1개의 연산자가 주어진다. 연산자는 덧셈(+), 뺄셈(-), 곱셈(×), 나눗셈(÷)으로만 이루어져 있다.

우리는 수와 수 사이에 연산자를 하나씩 넣어서, 수식을 하나 만들 수 있다. 이때, 주어진 수의 순서를 바꾸면 안 된다.

예를 들어, 6개의 수로 이루어진 수열이 1, 2, 3, 4, 5, 6이고, 주어진 연산자가 덧셈(+) 2개, 뺄셈(-) 1개, 곱셈(×) 1개, 나눗셈(÷) 1개인 경우에는 총 60가지의 식을 만들 수 있다. 예를 들어, 아래와 같은 식을 만들 수 있다.

1+2+3-4×5÷6
1÷2+3+4-5×6
1+2÷3×4-5+6
1÷2×3-4+5+6

식의 계산은 연산자 우선 순위를 무시하고 앞에서부터 진행해야 한다. 또, 나눗셈은 정수 나눗셈으로 몫만 취한다. 음수를 양수로 나눌 때는 C++14의 기준을 따른다. 즉, 양수로 바꾼 뒤 몫을 취하고, 그 몫을 음수로 바꾼 것과 같다. 이에 따라서, 위의 식 4개의 결과를 계산해보면 아래와 같다.

1+2+3-4×5÷6 = 1
1÷2+3+4-5×6 = 12
1+2÷3×4-5+6 = 5
1÷2×3-4+5+6 = 7

N개의 수와 N-1개의 연산자가 주어졌을 때, 만들 수 있는 식의 결과가 최대인 것과 최소인 것을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(2 ≤ N ≤ 11)가 주어진다. 둘째 줄에는 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 100) 셋째 줄에는 합이 N-1인 4개의 정수가 주어지는데, 차례대로 덧셈(+)의 개수, 뺄셈(-)의 개수, 곱셈(×)의 개수, 나눗셈(÷)의 개수이다.

출력

첫째 줄에 만들 수 있는 식의 결과의 최댓값을, 둘째 줄에는 최솟값을 출력한다. 연산자를 어떻게 끼워넣어도 항상 -10억보다 크거나 같고, 10억보다 작거나 같은 결과가 나오는 입력만 주어진다. 또한, 앞에서부터 계산했을 때, 중간에 계산되는 식의 결과도 항상 -10억보다 크거나 같고, 10억보다 작거나 같다.

import java.io.*
import kotlin.math.*

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val bw = BufferedWriter(OutputStreamWriter(System.out))

    val n = br.readLine().toInt()
    val nums = br.readLine().split(" ").map { it.toInt() }.toMutableList()
    val ops = br.readLine().split(" ").map { it.toInt() }.toMutableList()

    var maxValue = Integer.MIN_VALUE
    var minValue = Integer.MAX_VALUE

    fun dfs(depth: Int, x: Int) {
        if (depth == n) {
            maxValue = max(maxValue, x)
            minValue = min(minValue, x)
            return
        }

        // 연산자 종류만큼 반복.
        repeat(4) { index ->
            if (ops[index] != 0) {
                ops[index] -= 1
                when (index) {
                    0 -> dfs(depth + 1, x + nums[depth])
                    1 -> dfs(depth + 1, x - nums[depth])
                    2 -> dfs(depth + 1, x * nums[depth])
                    3 -> dfs(depth + 1, x / nums[depth])
                }
                ops[index] += 1
            }
        }
    }

    dfs(1, nums[0])

    bw.write("$maxValue\n")
    bw.write("$minValue\n")

    bw.flush()
    bw.close()
    br.close()
}

풀이

조합류 + n <= 20인 문제이기 때문에 dfs로 풀었습니다.

문제의 조건중 연산의 우선순위 없이 순서대로 계산한다는 점을 파악해야 했습니다.

모든 조합을 다 만들어보는 문제로

숫자 한번 연산한번 숫자 한번 연산 한번 dfs로 진행했습니다.

[원티드 안드로이드 프리온보딩] 프리온보딩을 마치며

hardy97 — Sun, 18 Dec 2022 00:42:08 +0900

원티드 안드로이드 프리온보딩을 마치며

(2022.12.3 ~ 2022.12.11)

느낀점

조금 늦었지만 짧게 원티드 안드로이드 프리온보딩에 참여했던 소감을 말하고자합니다.

먼저 강의는 '자바에서 코틀린으로'라는 타이틀에 걸맞게 강의의 전체적인 진행 방향은 Java와 Kotlin의 차이를 이론과 코드를 통해 학습하고 자바에서는 존재하지 않는 Kotlin 만의 장점을 보여주고, 부각시켰습니다.또 좀 의외의 강조점은 강사님께서 매번 강의가 끝나는 부분에 '코틀린 멀티 플랫폼'에 대한 설명을 해주셨습니다. 저는 좀 중요하지 않다고 생각했지만 코틀린 멀티 플랫폼이라는 것을 처음 알게되었고, 최근 플루터나 리액트네이티브에 대해 관심이 좀 있었는데 코틀린으로도 멀티플랫폼 개발이 가능하다는 얘기에 흥미가 생겼습니다.

나중에 시간이되면 코틀린으로 iOS 개발을 진행해보도록 하겠습니다.

강의에 대한 지식 재산권을 계속 강조하셔서 강의를 통해 공부한 내용을 블로그에 작성하진 못했습니다.

내용은 처음에는 매우 기초부터 알려주셔서, 안들어도 괜찮지 않을까 했는데. 생각보다 기초적인 부분도 모르는게 많았고 처음보는 문법도 생각보다 많았습니다. 강사님께서도 이런 사소한 부분을 설명할줄 아는게 차이를 만든다고 하셨고 면접에서도 유리하게 작용한다고 하셨습니다.

총 4일의 세션을 모두 참여했고 큰 주제는 아래와 같습니다.

Kotlin, Java의 타입시스템과 Null
Kotlin, Java의 흐름 제어와 클래스
Kotlin의 interface, operator, 컬렉션
Kotlin의 클래스 정의 및 활용, Scope 함수

강의의 학습자료만 직접적으로만 안하면 것인지 잘 모르겠지만 강의 자료와 다른 예시들을 제가 적용하면서 저의 생각들을 포함해서 복습하는 과정을 블로그에 기록해야겠습니다.

[KOTLIN] 백준-9663 N QEEN

hardy97 — Sun, 18 Dec 2022 00:30:15 +0900

백준-9663 NQEEN

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

9663번: N-Queen

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다. N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

www.acmicpc.net

문제

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다.

N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (1 ≤ N < 15)

출력

첫째 줄에 퀸 N개를 서로 공격할 수 없게 놓는 경우의 수를 출력한다.

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

var n = 0
var visited = Array(0, { Array(0, { false }) })

var count = 0

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val bw = BufferedWriter(OutputStreamWriter(System.out))

    n = br.readLine().toInt()
    visited = Array(n, { Array(n, { false }) })

    dfs(0)

    bw.write("$count")

    bw.flush()
    br.close()
    bw.close()
}

fun dfs(depth: Int) {
    if (depth == n) {
        count += 1
        return
    }

    repeat(n) { index ->
        if (!visited[depth][index] && possible(depth, index)) {
            visited[depth][index] = true
            dfs(depth + 1)
            visited[depth][index] = false
        }
    }
}

fun possible(depth: Int, index: Int): Boolean {
    // 윗 대각선과 같은 윗 선에 있는지 체크.
    // 같은 가로에는 있을일이 없다. 없을 시 바로 depth + 1로 넘어가기 때문
    repeat(depth) { i ->
        if (visited[i][index]) return false
        if ((index - depth + i) >= 0 && visited[i][index - depth + i]) return false
        if ((index + depth - i) < n && visited[i][index + depth - i]) return false
    }
    return true
}

풀이

수나 여부 그리고 20이하의 조건이므로 DFS를 사용하여 푼다.

첫째줄부터 아래로 내려가면서 해당 줄에 퀸을 놓을 수 있는지를 완전 탐색한다.

윗줄부터 내려오므로 현재 뎁스보다 밑에있는 줄에 퀸이 있을리가 없으므로 위만 생각하면 된다.

possible함수를 사용해서 같은 열에 이미 퀸이 있는지, 대각선에 퀸이 있는지를 visited 배열로 검사한다.

[KOTLIN] 백준-13305 주유소

hardy97 — Sat, 17 Dec 2022 23:40:15 +0900

백준-13305 주유소

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

13305번: 주유소

표준 입력으로 다음 정보가 주어진다. 첫 번째 줄에는 도시의 개수를 나타내는 정수 N(2 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 인접한 두 도시를 연결하는 도로의 길이가 제일 왼쪽 도로부터 N-1

www.acmicpc.net

문제

어떤 나라에 N개의 도시가 있다. 이 도시들은 일직선 도로 위에 있다. 편의상 일직선을 수평 방향으로 두자. 제일 왼쪽의 도시에서 제일 오른쪽의 도시로 자동차를 이용하여 이동하려고 한다. 인접한 두 도시 사이의 도로들은 서로 길이가 다를 수 있다. 도로 길이의 단위는 km를 사용한다.

처음 출발할 때 자동차에는 기름이 없어서 주유소에서 기름을 넣고 출발하여야 한다. 기름통의 크기는 무제한이어서 얼마든지 많은 기름을 넣을 수 있다. 도로를 이용하여 이동할 때 1km마다 1리터의 기름을 사용한다. 각 도시에는 단 하나의 주유소가 있으며, 도시 마다 주유소의 리터당 가격은 다를 수 있다. 가격의 단위는 원을 사용한다.

예를 들어, 이 나라에 다음 그림처럼 4개의 도시가 있다고 하자. 원 안에 있는 숫자는 그 도시에 있는 주유소의 리터당 가격이다. 도로 위에 있는 숫자는 도로의 길이를 표시한 것이다.

제일 왼쪽 도시에서 6리터의 기름을 넣고, 더 이상의 주유 없이 제일 오른쪽 도시까지 이동하면 총 비용은 30원이다. 만약 제일 왼쪽 도시에서 2리터의 기름을 넣고(2×5 = 10원) 다음 번 도시까지 이동한 후 3리터의 기름을 넣고(3×2 = 6원) 다음 도시에서 1리터의 기름을 넣어(1×4 = 4원) 제일 오른쪽 도시로 이동하면, 총 비용은 20원이다. 또 다른 방법으로 제일 왼쪽 도시에서 2리터의 기름을 넣고(2×5 = 10원) 다음 번 도시까지 이동한 후 4리터의 기름을 넣고(4×2 = 8원) 제일 오른쪽 도시까지 이동하면, 총 비용은 18원이다.

각 도시에 있는 주유소의 기름 가격과, 각 도시를 연결하는 도로의 길이를 입력으로 받아 제일 왼쪽 도시에서 제일 오른쪽 도시로 이동하는 최소의 비용을 계산하는 프로그램을 작성하시오.

입력

표준 입력으로 다음 정보가 주어진다. 첫 번째 줄에는 도시의 개수를 나타내는 정수 N(2 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 인접한 두 도시를 연결하는 도로의 길이가 제일 왼쪽 도로부터 N-1개의 자연수로 주어진다. 다음 줄에는 주유소의 리터당 가격이 제일 왼쪽 도시부터 순서대로 N개의 자연수로 주어진다. 제일 왼쪽 도시부터 제일 오른쪽 도시까지의 거리는 1이상 1,000,000,000 이하의 자연수이다. 리터당 가격은 1 이상 1,000,000,000 이하의 자연수이다.

출력

표준 출력으로 제일 왼쪽 도시에서 제일 오른쪽 도시로 가는 최소 비용을 출력한다.

풀이

가장 싼 기름값을 저장해두고 다음 목적지까지 이동한다. 그리고 다음 목적지의 가격이 더 비싸다면 그 가격 그대로 다음 목적지로 이동하고 더 싸다면 기름값을 바꾼다.

[KOTLIN] 백준-1260 DFS와 BFS

hardy97 — Fri, 16 Dec 2022 22:33:59 +0900

문제

그래프를 DFS로 탐색한 결과와 BFS로 탐색한 결과를 출력하는 프로그램을 작성하시오. 단, 방문할 수 있는 정점이 여러 개인 경우에는 정점 번호가 작은 것을 먼저 방문하고, 더 이상 방문할 수 있는 점이 없는 경우 종료한다. 정점 번호는 1번부터 N번까지이다.

입력

첫째 줄에 정점의 개수 N(1 ≤ N ≤ 1,000), 간선의 개수 M(1 ≤ M ≤ 10,000), 탐색을 시작할 정점의 번호 V가 주어진다. 다음 M개의 줄에는 간선이 연결하는 두 정점의 번호가 주어진다. 어떤 두 정점 사이에 여러 개의 간선이 있을 수 있다. 입력으로 주어지는 간선은 양방향이다.

출력

첫째 줄에 DFS를 수행한 결과를, 그 다음 줄에는 BFS를 수행한 결과를 출력한다. V부터 방문된 점을 순서대로 출력하면 된다.

import java.io.BufferedReader
import java.io.InputStreamReader
import java.io.BufferedWriter
import java.io.OutputStreamWriter
import java.util.LinkedList
import java.util.Queue

val br = BufferedReader(InputStreamReader(System.`in`))
val bw = BufferedWriter(OutputStreamWriter(System.out))

var board = Array(0, { Array(0, { 0 }) })
var visited = Array(0, { false })

var n = 0
var m = 0
var v = 0

fun main() {

    val (dn, dm, dv) = br.readLine().split(" ").map { it.toInt() }
    n = dn
    m = dm
    v = dv

    board = Array(dn + 1, { Array(dn + 1, { 0 }) })
    visited = Array(dn + 1, { false })

    repeat(m) {
        val (a, b) = br.readLine().split(" ").map { it.toInt() }
        board[a][b] = 1
        board[b][a] = 1
    }

    dfs(v, 1)
    visited = Array(dn + 1, { false })
    bw.write("\n")
    bfs(v)

    bw.flush()
    bw.close()
    br.close()
}

fun dfs(v: Int, depth: Int) {
    visited[v] = true
    bw.write("$v ")
    if (depth == n) return // 목적지에 도착
    board[v].forEachIndexed { index, i ->
        if (index != 0 && i != 0 && !visited[index]) {
            dfs(index, depth + 1)
        }
    }
}

fun bfs(start: Int) {
    val q: Queue<Int> = LinkedList()
    visited[start] = true
    q.add(start)

    while (!q.isEmpty()) {
        val current = q.poll()!!
        bw.write("$current ")
        board[current].forEachIndexed { index, i ->
            if (index != 0 && i != 0 && !visited[index]) {
                visited[index] = true
                val next = index
                q.add(next)
            }
        }
    }
}

[KOTLIN] 백준-1541 잃어버린 괄호

hardy97 — Fri, 16 Dec 2022 18:16:25 +0900

문제

세준이는 양수와 +, -, 그리고 괄호를 가지고 식을 만들었다. 그리고 나서 세준이는 괄호를 모두 지웠다.

그리고 나서 세준이는 괄호를 적절히 쳐서 이 식의 값을 최소로 만들려고 한다.

괄호를 적절히 쳐서 이 식의 값을 최소로 만드는 프로그램을 작성하시오.

입력

첫째 줄에 식이 주어진다. 식은 ‘0’~‘9’, ‘+’, 그리고 ‘-’만으로 이루어져 있고, 가장 처음과 마지막 문자는 숫자이다. 그리고 연속해서 두 개 이상의 연산자가 나타나지 않고, 5자리보다 많이 연속되는 숫자는 없다. 수는 0으로 시작할 수 있다. 입력으로 주어지는 식의 길이는 50보다 작거나 같다.

출력

첫째 줄에 정답을 출력한다.

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

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val bw = BufferedWriter(OutputStreamWriter(System.out))

    var nums = mutableListOf<Int>()
    val m = br.readLine().split("-")
    m.forEach { it ->
        val p = it.split("+").map{ it.toInt() }
        val sum = p.sum()
        nums.add(sum)
    }

    var result = nums[0]
    nums.forEachIndexed { index, value ->
        if(index != 0) result -= value
    }

    bw.write("$result")
    br.close()
    bw.close()
}

덧셈들끼리 괄호로 묶고 빼는 것이 가장 작은 값이 될 것이다.

때문에 처음에 - 로 나눴고 그 안에 정수들을 더했다

그리고 첫 숫자에서 합한 정수들을 빼주었다.