package LeetCode_980

/**
 * 980. Unique Paths III
 * https://leetcode.com/problems/unique-paths-iii/
 *
 * On a 2-dimensional grid, there are 4 types of squares:
1 represents the starting square.  There is exactly one starting square.
2 represents the ending square.  There is exactly one ending square.
0 represents empty squares we can walk over.
-1 represents obstacles that we cannot walk over.
Return the number of 4-directional walks from the starting square to the ending square,
that walk over every non-obstacle square exactly once.

Example 1:
Input: [
[1,0,0,0],
[0,0,0,0],
[0,0,2,-1]]
Output: 2
Explanation: We have the following two paths:
1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2)
2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)

Example 3:
Input: [
[0,1],
[2,0]]
Output: 0
Explanation:
There is no path that walks over every empty square exactly once.
Note that the starting and ending square can be anywhere in the grid.

Note:
1 <= grid.length * grid[0].length <= 20
 * 
 
*/
class Solution {
    /*
    * solution: DFS+Backtracking,
    * count the empty and start dfs from starting point, check if can reach the ending through by 4 directions.
    * Time: O(4^(m*n)), each position has 4 path to go,
    * Space: O(m*n)
    * */
    fun uniquePathsIII(grid: Array<IntArray>): Int {
        val m 
 
= grid.size
        val n = grid[0].size
        var startX = 0
        var startY = 0
        //init to 1, meaning the starting point have to go through also
        var needThroughCount = 1
        for (i in 0 until m) {
            for (j in 0 until n) {
                if (grid[i][j] == 0) {
                    needThroughCount
 
++
                } else if (grid[i][j] == 1) {
                    startX = i
                    startY = j
                }
            }
        }
        return dfs(grid, startX, startY, needThroughCount)
    }

    private fun dfs(grid: Array<IntArray>, x: Int, y: Int, needCount: Int): Int {
        if (x < 0 || y < 0 || x >= grid.size || y >= grid[0].size || grid[x][y] == -1) {
            return 0
        }
        //reach ending
        if (grid[x][y] == 2) {
            if (needCount == 0) {
                return 1
            } else {
                return 0
            }
        }
        //-1 represents obstacles that we cannot walk over
        grid[x][y] = -1
        var total = 0
        total += dfs(grid, x + 1, y, needCount)
        total += dfs(grid, x - 1, y, needCount)
        total += dfs(grid, x, y + 1, needCount)
        total += dfs(grid, x, y - 1, needCount)
        grid[x][y] = 0//for backtracking
        return total
    }
}