Leetcode进阶之路——Weekly Contest 144

1108. Defanging an IP Address

很简单的一道题，遍历字符串，给所有的'.'加方括号

class Solution {
public:
    string defangIPaddr(string address) {
        string s = "";
        for(int i = 0; i < address.length(); ++i)
            if(address[i] == '.')
            {
                s += "[.]";
                
            }
        else s += address[i];
        return s;
    }
};

1109. Corporate Flight Bookings

给定一个二维数组，数组中每个元素[i, j, k]分别表示从第i到第j个航班，有k个座位被预定
返回每个航班被预定的座位数
这道题跟前几周一个乘客上下车的题很像，类比为i为乘客上车时间，j为下车时间，k为上车人数，求每个时刻有多少人在车上，那么就维护一个数组，在i时刻+k，j时刻-k，最后累加起来即可：

class Solution {
public:
    vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
		vector<int> res(n, 0), sum(n, 0);
        for(auto flight: bookings)
        {
            sum[flight[0] - 1] += flight[2];
            if(flight[1] < n) sum[flight[1]] -= flight[2];
        }
        
        for(int i = 0; i < n; ++i)
        {
            if(i) res[i] = res[i - 1] + sum[i];
            else res[i] = sum[i];
        }
		return res;
	}
};

1110. Delete Nodes And Return Forest

给定一个二叉树（value唯一）和一个一维数组，数组中元素为二叉树中需要被删除的元素，返回删除这些元素后的二叉树
直接dfs，若当前节点的value在delete 数组中，则将其置NULL，同时将左右子节点添加进返回值中
考虑到左右子节点也有可能在delete数组，则对最后的数组进行一轮遍历，若根节点在delete数组，将其删除

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> delNodes(TreeNode* root, vector<int>& to_delete) {
		if (root == NULL) return {};
		map<int, int> m;
		for (int dele : to_delete)
			m[dele] = 1;
		vector<TreeNode*> res;
		res.emplace_back(root);
		dele(&root, res, m);
		vector<TreeNode*>::iterator it = res.begin();
		while (it != res.end())
		{
			if (m[(*it)->val]) it = res.erase(it);
			else it++;
		}
		return res;
	}

	void dele(TreeNode** root, vector<TreeNode*>& res, map<int, int>& m)
	{
		if (*root == NULL) return;
		if (m[(*root)->val])
		{
			if ((*root)->left != NULL)
			{
				res.emplace_back((*root)->left);
				dele(&(*root)->left, res, m);
			}
			if ((*root)->right != NULL)
			{
				res.emplace_back((*root)->right);
				dele(&(*root)->right, res, m);
			}
			*root = NULL;
		}
		else
		{
			dele(&(*root)->left, res, m);
			dele(&(*root)->right, res, m);
		}
	}
};

1111. Maximum Nesting Depth of Two Valid Parentheses Strings

题意：给定一个由括号组成的字符串，将其划分为两部分，使这两部分的深度最小
其中深度的定义： depth(A, B) = max(depth(A), depth(B))
若A、B均为有效括号，则AB也为有效括号，划分后的两部分在原字符串中可以不连续
这道题的难点应该在于理解题目，真正的代码是easy难度，其实就是假设原字符串有N对括号，将其拆分为两部分，分别有A对和B对括号（A+B=N），要求max(A, B)最小的划分方法
那很明显，就是对半分

class Solution {
public:
   vector<int> maxDepthAfterSplit(string seq) {
		int left = seq.length() / 4;
		int right = left;
		vector<int> res;
		for (int i = 0; i < seq.length(); ++i)
		{
			if (seq[i] == '(' && left)
			{
				left--;
				res.emplace_back(1);
			}
			else if (seq[i] == ')' && right)
			{
				right--;
				res.emplace_back(1);
			}
			else res.emplace_back(0);
		}
		return res;
	}
};