1182. 与目标颜色间的最短距离

1182. 与目标颜色间的最短距离

给你一个数组 colors，里面有 1、2、 3 三种颜色。

我们需要在 colors 上进行一些查询操作 queries，其中每个待查项都由两个整数 i 和 c 组成。

现在请你帮忙设计一个算法，查找从索引 i 到具有目标颜色 c 的元素之间的最短距离。

如果不存在解决方案，请返回 -1。

示例 1：

输入：colors = [1,1,2,1,3,2,2,3,3], queries = [[1,3],[2,2],[6,1]]
输出：[3,0,3]
解释： 
距离索引 1 最近的颜色 3 位于索引 4（距离为 3）。
距离索引 2 最近的颜色 2 就是它自己（距离为 0）。
距离索引 6 最近的颜色 1 位于索引 3（距离为 3）。

示例 2：

输入：colors = [1,2], queries = [[0,3]]
输出：[-1]
解释：colors 中没有颜色 3。

解法：DP

思想

问题拆分

目标颜色可能在左边也可能在右边，所以拆分成两个子问题

• 左边与目标颜色的最短距离
• 右边与目标颜色的最短距离

最后询问时，取 m i n { 左 边 与 目 标 颜 色 的 最 短 距 离 , 右 边 与 目 标 颜 色 的 最 短 距 离 } min \{左边与目标颜色的最短距离, 右边与目标颜色的最短距离\} min{左边与目标颜色的最短距离,右边与目标颜色的最短距离} 即可

状态表示

• $f(i,j)$ 表示从 colors[0] 开始到 colors[i] 结尾时与 $j$ 号颜色的最短距离（左边与目标颜色最短距离）
• $g(i,j)$ 表示从 colors[n - 1] 开始到 colors[i] 结尾时与 $j$ 号颜色的最短距离（右边与目标颜色最短距离）

状态转移

• 从 colors[0] 开始到 colors[i] 结尾时与 $j$ 号颜色的最短距离，与从 colors[0] 开始到 colors[i - 1] 结尾时与 $j$ 号颜色的最短距离有关，即 $f(i,j)$ 从 $f(i-1,j)$ 转移
• 从 colors[n - 1] 开始到 colors[i] 结尾时与 $j$ 号颜色的最短距离，与与从 colors[n - 1] 开始到 colors[i + 1] 结尾时与 $j$ 号颜色的最短距离有关，即 $g(i,j)$ 从 $g(i+1,j)$ 转移

复杂度

时间复杂度： O ( m a x { N , M } ) O(max \{N,M \}) O(max{N,M})，$N$ 为 colors 长度，$M$ 为 queries 长度

空间复杂度：$O(N)$

代码

class Solution {
    public List<Integer> shortestDistanceColor(int[] colors, int[][] queries) {
        int n = colors.length;
        int[][] f = new int[n + 1][4];
        int[][] g = new int[n + 1][4];
        
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= 3; j++) {
                f[i][j] = -1;
                g[i][j] = -1;
            }
        }
        
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= 3; j++) {
                if (colors[i - 1] == j) {
                    f[i][j] = 0;
                } else {
                    if (f[i - 1][j] == -1) f[i][j] = -1;
                    else f[i][j] = f[i - 1][j] + 1;
                }
            }
        }
        
        for (int i = n - 1; i >= 0; i--) {
            for (int j = 1; j <= 3; j++) {
                if (colors[i] == j) {
                    g[i][j] = 0;
                } else {
                    if (g[i + 1][j] == -1) g[i][j] = -1;
                    else g[i][j] = g[i + 1][j] + 1;
                }
            }
        }

        List<Integer> res = new ArrayList<>();
        for (var q : queries) {
            int a = f[q[0] + 1][q[1]], b = g[q[0]][q[1]];
            if (a == -1 && b == -1) res.add(-1);
            else if (a == -1) res.add(b);
            else if (b == -1) res.add(a);
            else res.add(Math.min(a, b));
        }
        
        return res;
    }

}