LeetCode 541. 反转字符串 II / 701. 二叉搜索树中的插入操作 / 807. 保持城市天际线

Posted 2021-09-08 Zephyr丶J

541. 反转字符串 II

2021.8.20 每日一题，八月已达下旬

题目描述

给定一个字符串 s 和一个整数 k，从字符串开头算起，每 2k 个字符反转前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例 1：

输入：s = “abcdefg”, k = 2
输出：“bacdfeg”

示例 2：

输入：s = “abcd”, k = 2
输出：“bacd”

提示：

1 <= s.length <= 104
s 仅由小写英文组成
1 <= k <= 104

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-string-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

class Solution {
    public String reverseStr(String s, int k) {
        StringBuffer sb = new StringBuffer();
        int l = s.length();
        int idx = 0;
        while(idx < l){
            int end1 = idx + k - 1 >= l ? l - 1 : idx + k - 1;
            int j = end1;
            while(j >= idx){
                sb.append(s.charAt(j));
                j--;
            }
            int end2 = end1 + k >= l ? l - 1 : end1 + k; 
            for(idx = end1 + 1; idx <= end2; idx++){
                sb.append(s.charAt(idx));
            }
        }
        return sb.toString();
    }
}

优雅的代码：

class Solution {
    public String reverseStr(String s, int k) {
        char[] cc = s.toCharArray();
        int l = cc.length;
        for(int i = 0; i < l; i += 2 * k){
            reverse(cc, i, Math.min(i + k, l) - 1);
        }
        return new String(cc);
    }

    public void reverse(char[] cc, int l, int r){
        while(l < r){
            char temp = cc[l];
            cc[l] = cc[r];
            cc[r] = temp;
            l++;
            r--;
        }
    }
}

701. 二叉搜索树中的插入操作

题目描述

给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

示例 1：

输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]
解释：另一个满足题目要求可以通过的树是：

示例 2：

输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：

输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
输出：[4,2,7,1,3,5]

提示：

给定的树上的节点数介于 0 和 10^4 之间
每个节点都有一个唯一整数值，取值范围从 0 到 10^8
-10^8 <= val <= 10^8
新值和原始二叉搜索树中的任意节点值都不同

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/insert-into-a-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

刚看这个题有点懵，感觉不知道该怎么插，因为感觉要调整树的结构，
然后看了一下例子，发现根据大小找到位置插入就行了，没必要调整树的结构

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        //试了两个，好像都能通过二叉搜索树的规律，找打要插入的点
        if(root == null)
            return new TreeNode(val);
        TreeNode node = root;
        while(root != null){
            if(root.val < val){
                if(root.right != null)
                    root = root.right;
                else{
                    root.right = new TreeNode(val);
                    break;
                }
            }else{
                if(root.left != null)
                    root = root.left;
                else{
                    root.left = new TreeNode(val);
                    break;
                }
            }
        }
        return node;
    }
}

递归

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        //试了两个，好像都能通过二叉搜索树的规律，找打要插入的点
        if(root == null)
            return new TreeNode(val);
        if(root.val > val)
            root.left = insertIntoBST(root.left, val);
        else
            root.right = insertIntoBST(root.right, val);
        return root;
    }
}

807. 保持城市天际线

题目描述

在二维数组grid中，grid[i][j]代表位于某处的建筑物的高度。 我们被允许增加任何数量（不同建筑物的数量可能不同）的建筑物的高度。 高度 0 也被认为是建筑物。

最后，从新数组的所有四个方向（即顶部，底部，左侧和右侧）观看的“天际线”必须与原始数组的天际线相同。 城市的天际线是从远处观看时，由所有建筑物形成的矩形的外部轮廓。 请看下面的例子。

建筑物高度可以增加的最大总和是多少？

例子：

输入： grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
输出： 35
解释：
The grid is:
[ [3, 0, 8, 4],
[2, 4, 5, 7],
[9, 2, 6, 3],
[0, 3, 1, 0] ]

从数组竖直方向（即顶部，底部）看“天际线”是：[9, 4, 8, 7]
从水平水平方向（即左侧，右侧）看“天际线”是：[8, 7, 9, 3]
在不影响天际线的情况下对建筑物进行增高后，新数组如下：
gridNew = [ [8, 4, 8, 7],
[7, 4, 7, 7],
[9, 4, 8, 7],
[3, 3, 3, 3] ]

说明:

1 < grid.length = grid[0].length <= 50。
grid[i][j] 的高度范围是： [0, 100]。
一座建筑物占据一个grid[i][j]：换言之，它们是 1 x 1 x grid[i][j] 的长方体。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/max-increase-to-keep-city-skyline
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

class Solution {
    public int maxIncreaseKeepingSkyline(int[][] grid) {
        //因为前后看是一样的，左右看也是一样的
        //所以先确定横向和纵向的两个数组
        //然后根据这两个数组相交，确定每一个点的高度，然后减去原来的高度，就是最后结果
        int l = grid.length;
        int[] row = new int[l];     //由每一列的最大值组成
        int[] col = new int[l];     //由每一行的最大值组成
        for(int i = 0; i < l; i++){
            for(int j = 0; j < l; j++){
                col[i] = Math.max(grid[i][j], col[i]);
                row[j] = Math.max(row[j], grid[i][j]);
            }
        }

        int res = 0;
        for(int i = 0; i < l; i++){
            for(int j = 0; j < l; j++){
                res += Math.min(row[j], col[i]) - grid[i][j];
            }
        }
        return res;
    }
}