1122. 数组的相对排序
      给你两个数组，arr1 和 arr2，arr2 中的元素各不相同，arr2 中的每个元素都出现在 arr1 中。对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾

自定义排序规则进行排序即可

class Solution {
public:vector relativeSortArray(vector& arr1, vector& arr2) {unordered_map rank;for (int i = 0; i < arr2.size(); ++i) {rank[arr2[i]] = i;}auto mycmp = [&](int x) -> pair {return rank.count(x) ? pair{0, rank[x]} : pair{1, x};};sort(arr1.begin(), arr1.end(), [&](int x, int y) {return mycmp(x) < mycmp(y);});return arr1;}
};

1123. 最深叶节点的最近公共祖先
      给你一个有根节点 root 的二叉树，返回它 最深的叶节点的最近公共祖先 。

class Solution {
public://求当前结点的深度int depth(TreeNode* root){if(!root) return 0;int left = depth(root->left);int right = depth(root->right);return 1+max(left, right);}TreeNode* lcaDeepestLeaves(TreeNode* root) {if(!root) return NULL;int left = depth(root->left); //左树深度int right = depth(root->right); //右树深度if(left == right){ //如果左右两边深度相等，那么当前结点就是最近公共祖先return root;}else if(left>right){ //左边更深，那么就去左边找return lcaDeepestLeaves(root->left);}else{return lcaDeepestLeaves(root->right);}}
};

1124. 表现良好的最长时间段
      给你一份工作时间表 hours，上面记录着某一位员工每天的工作小时数。我们认为当员工一天中的工作小时数大于 8 小时的时候，那么这一天就是「劳累的一天」。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。请你返回「表现良好时间段」的最大长度。

不难想到将大于8改成1、-1，然后记录前缀和，根据前缀和用暴力法即可求最大子数组。但是更巧妙的做法是利用单调栈记录递减的前缀和索引，然后逆向遍历去找寻最大的子数组。

class Solution {
public:int longestWPI(vector& hours) {// 处理数组为每天的得分int n = hours.size();for(int i = 0; i < n; i++){if(hours[i] > 8) hours[i] = 1;else hours[i] = -1;}// 求前缀和int pre[n + 1];memset(pre, 0, sizeof(pre));for(int i = 1; i <= n; i++){pre[i] = pre[i - 1] + hours[i - 1];}// 单调栈记录前缀和的递减下标（★也就是首次最低值下标）stack s; while(s.size()) s.pop();for(int i = 0; i <= n; i++){if(s.empty() || pre[s.top()] > pre[i]){s.push(i);}}int ans = 0;// 枚举右边界for(int i = n; i >= 0; i--){if(s.empty()) break;while(!s.empty() && s.top() >= i) s.pop();while(!s.empty() && pre[s.top()] < pre[i]){ans = max(ans, i - s.top());s.pop();}}return ans;}
};

1125. 最小的必要团队
      请你返回 任一 规模最小的必要团队，团队成员用人员编号表示。你可以按 任意顺序 返回答案，题目数据保证答案存在。

状态压缩DP

class Solution {
public:vector smallestSufficientTeam(const vector& req_skills, const vector>& people) {const int skillCnt = req_skills.size();unordered_map map;for (int i = 0; i < skillCnt; ++i){map[req_skills[i]] = i;}const int peopleCnt = people.size();vector skill(peopleCnt);for (int i = 0; i < peopleCnt; ++i){for (const auto & x : people[i]){skill[i] |= 1 << map[x];}}const int stateCnt = 1 << skillCnt;vector> dp(1 << skillCnt);int maxDPState = 0;for (int i = 0; i < peopleCnt; ++i){if (skill[i] == 0){continue;}for (int j = 0; j <= maxDPState; ++j){if (j && dp[j].empty()){continue;}int combination = skill[i] | j;if (dp[combination].empty() || dp[j].size() + 1 < dp[combination].size()){dp[combination] = dp[j];dp[combination].emplace_back(i);}}maxDPState |= skill[i];}return dp.back();}
};

1128. 等价多米诺骨牌对的数量
      给你一个由一些多米诺骨牌组成的列表 dominoes。如果其中某一张多米诺骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。形式上，dominoes[i] = [a, b] 和 dominoes[j] = [c, d] 等价的前提是 ac 且 bd，或是 ad 且 bc。在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。

直接翻转数组至全部满足元素递增即可，然后挨个统计数字。

class Solution {
public:int numEquivDominoPairs(vector>& dominoes) {vector num(100);int ret = 0;for (auto& it : dominoes) {int val = it[0] < it[1] ? it[0] * 10 + it[1] : it[1] * 10 + it[0];ret += num[val];num[val]++;}return ret;}
};

1129. 颜色交替的最短路径
      在一个有向图中，节点分别标记为 0, 1, …, n-1。图中每条边为红色或者蓝色，且存在自环或平行边。red_edges 中的每一个 [i, j] 对表示从节点 i 到节点 j 的红色有向边。类似地，blue_edges 中的每一个 [i, j] 对表示从节点 i 到节点 j 的蓝色有向边。返回长度为 n 的数组 answer，其中 answer[X] 是从节点 0 到节点 X 的红色边和蓝色边交替出现的最短路径的长度。如果不存在这样的路径，那么 answer[x] = -1。

BFS

class Solution {
public:vector shortestAlternatingPaths(int n, vector>& redEdges, vector>& blueEdges) {vector>> graph(n);vector> visited(n,vector(2,0));//0表示red 1表示bluefor(auto& edge:redEdges){int from=edge[0];int to=edge[1];graph[from].push_back({to,0});}for(auto& edge:blueEdges){int from=edge[0];int to=edge[1];graph[from].push_back({to,1});}queue> q;vector dis(n,INT_MAX);dis[0]=0;q.push({0,0,1});//节点 距离 颜色q.push({0,0,0});while(!q.empty()){auto it=q.front();int from=it[0];int distance=it[1];int col=it[2];q.pop();for(auto& [to,colour]:graph[from]){if(colour==(!col) && !visited[to][colour]){dis[to]=min(dis[to],distance+1);q.push({to,distance+1,colour});visited[to][colour]=1;}}}for(int i=0;iif(dis[i]==INT_MAX)dis[i]=-1;}return dis;}
};

1130. 叶值的最小代价生成树
      给你一个正整数数组 arr，考虑所有满足以下条件的二叉树：
      每个节点都有 0 个或是 2 个子节点。
      数组 arr 中的值与树的中序遍历中每个叶节点的值一一对应。（知识回顾：如果一个节点有 0 个子节点，那么该节点为叶节点。）
      每个非叶节点的值等于其左子树和右子树中叶节点的最大值的乘积。
      在所有这样的二叉树中，返回每个非叶节点的值的最小可能总和。这个和的值是一个 32 位整数。

两个数的最小乘积必然是选择数组中最小的两个数（且这两个数相邻），并且这种局部最优算法会继续优化我们后续的算法，因为我们选择是两个最小的正数，而合并的时候虽然选择的是两个数中最大的一个，但这个数仍然是整个数组最小的数，也就是我们做出的贪心选择，下一步也将是最优的

class Solution {
public:int mctFromLeafValues(vector& arr) {int ans=0,pos=0;while(arr.size()>1){int Min=INT_MAX;for(int i=0;iif(Min>arr[i]*arr[i+1])//找到最小的两个值{Min=arr[i]*arr[i+1];pos=arr[i]