Submission #24810503

---

Source Code Expand

@file:Suppress("DuplicatedCode")

import java.io.IOException
import java.io.InputStream
import java.io.PrintWriter
import java.util.NoSuchElementException

fun main(args: Array<String>) {
    PrintWriter(System.out).use { out ->
        P012.solve(P012.FastScanner(), out)
        out.flush()
    }
}

private fun P012.solve(sc: P012.FastScanner, out: PrintWriter) {
    val H = sc.nextInt()
    val W = sc.nextInt()
    val Q = sc.nextInt()

    val li = BooleanArray(H * W)
    val uf = P012.UnionFind(H * W)

    repeat(Q) { _ ->
        val type = sc.nextInt()
        if (type == 1) {
            val r = sc.nextInt() - 1
            val c = sc.nextInt() - 1
            val index = r * W + c
            li[index] = true

            if (r != 0) {
                val pos = (r - 1) * W + c
                if (li[pos]) uf.unite(index, pos)
            }

            if (r != H - 1) {
                val pos = (r + 1) * W + c
                if (li[pos]) uf.unite(index, pos)
            }

            if (c != 0) {
                val pos = r * W + c - 1
                if (li[pos]) uf.unite(index, pos)
            }

            if (c != W - 1) {
                val pos = r * W + c + 1
                if (li[pos]) uf.unite(index, pos)
            }
        } else {
            val r1 = sc.nextInt() - 1
            val c1 = sc.nextInt() - 1
            val fp = r1 * W + c1
            val r2 = sc.nextInt() - 1
            val c2 = sc.nextInt() - 1
            val sp = r2 * W + c2

            val msg = if (li[fp] && li[sp] && uf.same(fp, sp)) "Yes" else "No"
            out.println(msg)
        }
    }
}

@Suppress("MemberVisibilityCanBePrivate")
private object P012 {
    private const val zeroCode = '0'.toInt()
    private const val nineCode = '9'.toInt()

    class FastScanner {
        private val `in`: InputStream = System.`in`
        private val buffer = ByteArray(2048)
        private var ptr = 0
        private var buflen = 0

        private fun hasNextByte(): Boolean {
            if (ptr < buflen) {
                return true
            } else {
                ptr = 0
                try {
                    buflen = `in`.read(buffer)
                } catch (e: IOException) {
                    e.printStackTrace()
                }
                if (buflen <= 0) {
                    return false
                }
            }
            return true
        }

        private fun readByte(): Byte = if (hasNextByte()) buffer[ptr++] else -1

        private fun readByteAsInt(): Int = if (hasNextByte()) buffer[ptr++].toInt() else -1

        operator fun hasNext(): Boolean {
            while (hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++
            return hasNextByte()
        }

        operator fun next(): String {
            if (!hasNext()) throw NoSuchElementException()

            return buildString {
                var b = readByteAsInt()

                while (isPrintableChar(b)) {
                    appendCodePoint(b)
                    b = readByteAsInt()
                }
            }
        }

        fun toCharIterator(): CharIterator = object : CharIterator() {
            private var nextByte: Byte = readByte()

            override fun hasNext(): Boolean = isPrintableChar(nextByte)

            override fun nextChar(): Char {
                val res = nextByte
                nextByte = readByte()
                return res.toChar()
            }

        }

        fun nextLong(): Long {
            if (!hasNext()) throw NoSuchElementException()
            var n: Long = 0
            var minus = false
            var b = readByteAsInt()

            if (b == '-'.toInt()) {
                minus = true
                b = readByteAsInt()
            }

            if (b !in zeroCode..nineCode) {
                throw NumberFormatException()
            }

            while (true) {
                if (b in zeroCode..nineCode) {
                    n *= 10
                    n += b - zeroCode.toLong()
                } else if (b == -1 || !isPrintableChar(b)) {
                    return if (minus) -n else n
                } else {
                    throw NumberFormatException()
                }

                b = readByteAsInt()
            }
        }

        fun nextInt(): Int {
            val nl = nextLong()
            if (nl < Int.MIN_VALUE || nl > Int.MAX_VALUE) throw NumberFormatException()
            return nl.toInt()
        }

        fun nextDouble(): Double {
            return next().toDouble()
        }

        fun readIntArray(n: Int): IntArray {
            val arr = IntArray(n)

            for (i in 0 until n) {
                arr[i] = nextInt()
            }

            return arr
        }

        fun readBigInt(capacity: Int): IntArray {
            if (!hasNext()) throw NoSuchElementException()

            val arr = IntArray(capacity)
            var len = 0
            arr[0] = readByteAsInt() - zeroCode
            while (arr[len] in 0..9) {
                len++
                arr[len] = readByteAsInt() - zeroCode
            }

            return arr.sliceArray(0 until len)
        }

        companion object {
            private inline fun isPrintableChar(c: Int): Boolean {
                return c in 33..126
            }

            private inline fun isPrintableChar(c: Byte): Boolean {
                return c in 33..126
            }
        }
    }

    class UnionFind(val size: Int) {
        val par = IntArray(size) { it }
        val rank = IntArray(size)

        fun root(pos: Int): Int = if (par[pos] == pos) pos else {
            par[pos] = root(par[pos])
            par[pos]
        }

        fun same(x: Int, y: Int) = root(x) == root(y)

        fun unite(x: Int, y: Int) {
            val x = root(x)
            val y = root(y)

            if (x == y) return

            if (rank[x] < rank[y]) {
                par[x] = y
            } else {
                par[y] = x
                if (rank[x] == rank[y]) rank[x]++
            }
        }
    }
}

Submission Info

Compile Error

warning: ATTENTION!
This build uses unsafe internal compiler arguments:

-XXLanguage:+InlineClasses

This mode is not recommended for production use,
as no stability/compatibility guarantees are given on
compiler or generated code. Use it at your own risk!

Main.kt:191:21: warning: expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types
            private inline fun isPrintableChar(c: Int): Boolean {
                    ^
Main.kt:195:21: warning: expected performance impact from inlining is insignificant. Inlining works best for functions with parameters of functional types
            private inline fun isPrintableChar(c: Byte): Boolean {
                    ^
Main.kt:213:17: warning: name shadowed: x
            val x = root(x)
                ^
Main.kt:214:17: warning: name shadowed: y
            val y = root(y)
                ^

Judge Result