【leetcode刷题第42天】1706.球会落在何处、537.复数乘法、1138.字母板上的路径

第四十二天

1706 球会落在何处

用一个大小为 m x n 的二维网格 grid 表示一个箱子。你有 n 颗球。箱子的顶部和底部都是开着的。

箱子中的每个单元格都有一个对角线挡板，跨过单元格的两个角，可以将球导向左侧或者右侧。

• 将球导向右侧的挡板跨过左上角和右下角，在网格中用 1 表示。

• 将球导向左侧的挡板跨过右上角和左下角，在网格中用 -1 表示。

在箱子每一列的顶端各放一颗球。每颗球都可能卡在箱子里或从底部掉出来。如果球恰好卡在两块挡板之间的 “V” 形图案，或者被一块挡导向到箱子的任意一侧边上，就会卡住。

返回一个大小为 n 的数组 answer ，其中 answer[i] 是球放在顶部的第i 列后从底部掉出来的那一列对应的下标，如果球卡在盒子里，则返回 -1 。

示例 1：

输入：grid = [[1,1,1,-1,-1],[1,1,1,-1,-1],[-1,-1,-1,1,1],[1,1,1,1,-1],[-1,-1,-1,-1,-1]]
输出：[1,-1,-1,-1,-1]

方法

考虑如下事实：

• 对于每一个小球，如果我们知道了它在上一层的状态，以及地图的状态，我们就能够得到它在下一层的状态
• 一个小球能够到达下一层，有以下限制条件：
  • 这个小球下方的地图网格朝向和 与该网格朝向相同且相邻 的网格同时存在
  • 这个小球下方的网格如果朝向左，那么这个小球当前的位置不能够在最左边
  • 这个小球下方的网格如果朝向右，那么这个小球当前的位置不能够在最右边

为此，我们定义dp[i][j]来表示在第i层的第j个小球将要到达的下一层的位置，如果不能够到达下一层，那么我们就将该值置为-1。

具体的算法逻辑同以上分析，见代码注释。

class Solution {
    public int[] findBall(int[][] grid) {
        int[][] dp = new int[grid.length + 1][grid[0].length];
        for (int i = 0; i < grid[0].length; ++i) dp[0][i] = i;
        for (int i = 1; i <= grid.length; ++i) {
            for (int j = 0; j < grid[0].length; ++j) {
                if (dp[i - 1][j] == -1) { //如果上一层已经是死角了 那么直接将下一层置为死角
                    dp[i][j] = -1;
                    continue;
                }
                int dir = grid[i - 1][dp[i - 1][j]]; //当前小球下方对应的网格的朝向
                if (dp[i - 1][j] == 0 && dir == -1) { //如果当前小球下方的网格朝向左 同时这个小球在最左边 那么说明这小球进入到了死角
                    dp[i][j] = -1;
                    continue;
                }   
                if (dp[i - 1][j] == grid[0].length - 1 && dir == 1) { //同理 在最右边的死角
                    dp[i][j] = -1;
                    continue;
                }
                if (grid[i - 1][dp[i - 1][j] + dir] != dir) { //如果当前小球下方的网格的朝向 和 与其相邻的网格的朝向不一致 那么说明这个小球将要到达一个`V`形死角
                    dp[i][j] = -1;
                }
                else {
                    dp[i][j] = dp[i - 1][j] + dir;//小球能够顺利到达下一层
                }
            }
        }
        return dp[grid.length];//返回答案
    }
}

537 复数乘法

复数 可以用字符串表示，遵循 "实部+虚部i" 的形式，并满足下述条件：

• 实部 是一个整数，取值范围是 [-100, 100]

• 虚部 也是一个整数，取值范围是 [-100, 100]

• i2 == -1

给你两个字符串表示的复数 num1 和 num2 ，请你遵循复数表示形式，返回表示它们乘积的字符串。

示例 1：

输入：num1 = "1+1i", num2 = "1+1i"
输出："0+2i"
解释：(1 + i) * (1 + i) = 1 + i2 + 2 * i = 2i ，你需要将它转换为 0+2i 的形式。

方法

直接模拟即可。

class Solution {
    public String complexNumberMultiply(String num1, String num2) {
        String[] complex1 = num1.split("\\+");
        String[] complex2 = num2.split("\\+");
        int real1 = getValue(complex1[0], ' ');
        int virtual1 = getValue(complex1[1], 'i');
        int real2 = getValue(complex2[0], ' ');
        int virtual2 = getValue(complex2[1], 'i');
        int real = real1 * real2 - virtual1 * virtual2;
        int virtual = real1 * virtual2 + real2 * virtual1;
        return real + "+" + virtual + "i";
    }
    public int getValue(String complex, char stopChar) {
        int sign = complex.charAt(0) == '-' ? -1 : 1;
        int res = 0;
        for (int i = (sign == -1) ? 1 : 0; i < complex.length(); ++i) {
            if (complex.charAt(i) != stopChar) res = res * 10 + (complex.charAt(i) - '0');
            else break;
        }
        return sign * res;
    }
}

1138 字母板上的路径

我们从一块字母板上的位置 (0, 0) 出发，该坐标对应的字符为 board[0][0]。

在本题里，字母板为board = ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"]，如下所示。
$$\left|\begin{array}{ccccc}a& b& c& d& e\\ f& g& h& i& j\\ k& l& m& n& o\\ p& q& r& s& t\\ u& v& w& x& y\\ z& & & & \end{array}\right|$$
我们可以按下面的指令规则行动：

• 如果方格存在，'U' 意味着将我们的位置上移一行；

• 如果方格存在，'D' 意味着将我们的位置下移一行；

• 如果方格存在，'L' 意味着将我们的位置左移一列；

• 如果方格存在，'R' 意味着将我们的位置右移一列；

• '!' 会把在我们当前位置 (r, c) 的字符 board[r][c] 添加到答案中。

（注意，字母板上只存在有字母的位置。）

返回指令序列，用最小的行动次数让答案和目标 target 相同。你可以返回任何达成目标的路径。

示例 1：

输入：target = "leet"
输出："DDR!UURRR!!DDD!"

方法

由于我们已经知道了所有的字母，对于相邻的两个字母，其最近的距离就是他们的曼哈顿距离，即横坐标差加上纵坐标差。但是需要注意的一点是，对于从一个字母走到z和从z走到另外一个字母，它们之间的路径不能随意走，需要先走竖直距离然后再走水平距离。

class Solution {
    public String alphabetBoardPath(String target) {
        StringBuilder res = new StringBuilder();
        int x = 0, y = 0;
        for (int i = 0; i < target.length(); ++i) {
            int dx = x - (target.charAt(i) - 'a') % 5;
            int dy = y - (target.charAt(i) - 'a') / 5;
            if (dx < 0 && dy > 0) {
                processWayStr(res, 'U', dy);
                processWayStr(res, 'R', -dx);
            }
            else if (dx > 0 && dy < 0) {
                processWayStr(res, 'L', dx);
                processWayStr(res, 'D', -dy);
            }
            else {
                processWayStr(res, dx > 0 ? 'L' : 'R', Math.abs(dx));
                processWayStr(res, dy > 0 ? 'U' : 'D', Math.abs(dy));
            }
            res.append('!');
            x = (target.charAt(i) - 'a') % 5;
            y = (target.charAt(i) - 'a') / 5;
        }
        return res.toString();
    }
    
    public void processWayStr(StringBuilder res, char dir, int time) {
        while (time-- > 0) res.append(dir);
    }
}