結果

問題 No.124 門松列(3)
ユーザー バカらっくバカらっく
提出日時 2019-10-02 11:24:11
言語 Kotlin
(1.9.23)
結果
AC  
実行時間 3,042 ms / 5,000 ms
コード長 2,390 bytes
コンパイル時間 16,638 ms
コンパイル使用メモリ 457,812 KB
実行使用メモリ 143,540 KB
最終ジャッジ日時 2024-10-03 05:56:56
合計ジャッジ時間 48,021 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 3,042 ms
143,540 KB
testcase_01 AC 357 ms
55,700 KB
testcase_02 AC 359 ms
55,608 KB
testcase_03 AC 2,945 ms
125,984 KB
testcase_04 AC 466 ms
58,464 KB
testcase_05 AC 452 ms
58,080 KB
testcase_06 AC 357 ms
55,708 KB
testcase_07 AC 356 ms
55,644 KB
testcase_08 AC 359 ms
55,732 KB
testcase_09 AC 356 ms
55,504 KB
testcase_10 AC 357 ms
55,780 KB
testcase_11 AC 369 ms
55,624 KB
testcase_12 AC 358 ms
55,624 KB
testcase_13 AC 357 ms
55,676 KB
testcase_14 AC 384 ms
56,356 KB
testcase_15 AC 414 ms
57,944 KB
testcase_16 AC 2,948 ms
142,212 KB
testcase_17 AC 417 ms
57,848 KB
testcase_18 AC 391 ms
56,368 KB
testcase_19 AC 2,861 ms
118,028 KB
testcase_20 AC 2,913 ms
137,580 KB
testcase_21 AC 429 ms
58,372 KB
testcase_22 AC 2,843 ms
118,516 KB
testcase_23 AC 398 ms
56,624 KB
testcase_24 AC 429 ms
57,148 KB
testcase_25 AC 423 ms
57,108 KB
testcase_26 AC 381 ms
56,204 KB
testcase_27 AC 376 ms
55,964 KB
testcase_28 AC 456 ms
58,260 KB
testcase_29 AC 466 ms
58,300 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
Main.kt:3:10: warning: parameter 'args' is never used
fun main(args:Array<String>) {
         ^
Main.kt:51:115: warning: unnecessary non-null assertion (!!) on a non-null receiver of type Map.Entry<Int, Int>
        var ans = dic[dic.lastIndex].let { it[it.lastIndex] }.let { if(it.isEmpty()) -1 else it.minBy { it.value }!!.value }
                                                                                                                  ^

ソースコード

diff # 

import java.util.*

fun main(args:Array<String>) {
    val (w,h) = readLine()!!.split(" ").map { it.toInt() }
    Proc(w, h).getAns()
}

class Proc(val w:Int, val h:Int) {
    val map = (0 until h).map { a-> readLine()!!.split(" ").withIndex().map { b-> Pos(b.index, a, b.value.toInt(), w) } }
    val dic = (0 until h).map { (0 until w).map { mutableMapOf<Int, Int>() } }
    public fun getAns() {
        val queue = LinkedList<Task>()
        queue.push(Task(map[0][0], null, 0))
        while (queue.isNotEmpty()) {
            val t = queue.pop()
            val prevKey = t.prev?.let { it.index }?:-1
            if(dic[t.current.y][t.current.x].containsKey(prevKey) && dic[t.current.y][t.current.x][prevKey]!! <= t.step) {
                continue
            }
            dic[t.current.y][t.current.x][prevKey] = t.step
            for(i in (t.current.y - 1..t.current.y + 1)) {
                if(i < 0 || i > map.lastIndex) {
                    continue
                }
                for(j in (t.current.x - 1.. t.current.x + 1)) {
                    if(j < 0 || j > map[i].lastIndex) {
                        continue
                    }
                    if(i == t.current.y && j == t.current.x) {
                        continue
                    }
                    if(i != t.current.y && j != t.current.x) {
                        continue
                    }
                    if(t.prev != null) {
                        if(i == t.prev.y && j == t.prev.x) {
                            continue
                        }
                        val tmp = listOf(t.prev.z, t.current.z, map[i][j].z)
                        if(tmp.distinct().size != 3) {
                            continue
                        }
                        if(tmp.max() != tmp[1] && tmp.min() != tmp[1]) {
                            continue
                        }
                    }
                    queue.push(Task(map[i][j], t.current, t.step + 1))
                }
            }
        }
        var ans = dic[dic.lastIndex].let { it[it.lastIndex] }.let { if(it.isEmpty()) -1 else it.minBy { it.value }!!.value }
        if(ans <= 0) {
            ans = -1
        }
        println(ans)
    }
    class Pos(val x:Int, val y:Int, val z:Int, val w:Int) {
        val index = y * w + x
    }
    class Task(val current:Pos, val prev:Pos?, val step:Int)
}
0