zoukankan      html  css  js  c++  java
  • LeetCode 第 27 场双周赛

    现场还是想的太暴力了,枚举二进制值,BFS 不加 vis ,导致前面 T 了好几发。

    5408.通过翻转子数组使两个数组相等

    给你两个长度相同的整数数组 target 和 arr 。

    每一步中,你可以选择 arr 的任意 非空子数组 并将它翻转。你可以执行此过程任意次。

    如果你能让 arr 变得与 target 相同,返回 True;否则,返回 False 。

    示例 1:

    输入:target = [1,2,3,4], arr = [2,4,1,3]
    输出:true
    解释:你可以按照如下步骤使 arr 变成 target:
    1- 翻转子数组 [2,4,1] ,arr 变成 [1,4,2,3]
    2- 翻转子数组 [4,2] ,arr 变成 [1,2,4,3]
    3- 翻转子数组 [4,3] ,arr 变成 [1,2,3,4]
    上述方法并不是唯一的,还存在多种将 arr 变成 target 的方法。
    

    示例 2:

    输入:target = [7], arr = [7]
    输出:true
    解释:arr 不需要做任何翻转已经与 target 相等。
    

    示例 3:

    输入:target = [1,12], arr = [12,1]
    输出:true
    

    示例 4:

    输入:target = [3,7,9], arr = [3,7,11]
    输出:false
    解释:arr 没有数字 9 ,所以无论如何也无法变成 target 。
    

    示例 5:

    输入:target = [1,1,1,1,1], arr = [1,1,1,1,1]
    输出:true
    

    提示:

    target.length == arr.length
    1 <= target.length <= 1000
    1 <= target[i] <= 1000
    1 <= arr[i] <= 1000
    

    对比两个是否相同即可,sort 下就行

    class Solution {
     public:
      bool canBeEqual(vector<int>& target, vector<int>& arr) {
        sort(target.begin(), target.end());
        sort(arr.begin(), arr.end());
        if(target.size() != arr.size())
          return false;
        for(int i = 0, n = arr.size(); i < n; ++i)
          if(arr[i] != target[i])
            return false;
        return true;
      }
    };
    

    5409. 检查一个字符串是否包含所有长度为 K 的二进制子串

    给你一个二进制字符串 s 和一个整数 k 。

    如果所有长度为 k 的二进制字符串都是 s 的子串,请返回 True ,否则请返回 False 。

    示例 1:

    输入:s = "00110110", k = 2
    输出:true
    解释:长度为 2 的二进制串包括 "00","01","10" 和 "11"。它们分别是 s 中下标为 0,1,3,2 开始的长度为 2 的子串。
    

    示例 2:

    输入:s = "00110", k = 2
    输出:true
    

    示例 3:

    输入:s = "0110", k = 1
    输出:true
    解释:长度为 1 的二进制串包括 "0" 和 "1",显然它们都是 s 的子串。
    

    示例 4:

    输入:s = "0110", k = 2
    输出:false
    解释:长度为 2 的二进制串 "00" 没有出现在 s 中。
    

    示例 5:

    输入:s = "0000000001011100", k = 4
    输出:false
    

    提示:

    1 <= s.length <= 5 * 10^5
    s 中只含 0 和 1 。
    1 <= k <= 20
    

    暴力枚举 00001111(k位) TLE 了。
    暴力枚举 s 中长位 k 子串,然后统计这些子串的值是否是 0 到 (1<<k)

    class Solution {
     public:
      bool hasAllCodes(string s, int k) {
        const int n = s.length();
        set<int>st;
        for(int i = 0; i <= n - k; ++i) {
          string ss = s.substr(i, k);
          st.insert(stoi(ss, 0, 2));
        }
        return st.size() == (1 << k);
      }
    };
    

    5410. 课程安排 IV

    你总共需要上 n 门课,课程编号依次为 0 到 n-1 。

    有的课会有直接的先修课程,比如如果想上课程 0 ,你必须先上课程 1 ,那么会以 [1,0] 数对的形式给出先修课程数对。

    给你课程总数 n 和一个直接先修课程数对列表 prerequisite 和一个查询对列表 queries 。

    对于每个查询对 queries[i] ,请判断 queries[i][0] 是否是 queries[i][1] 的先修课程。

    请返回一个布尔值列表,列表中每个元素依次分别对应 queries 每个查询对的判断结果。

    注意:如果课程 a 是课程 b 的先修课程且课程 b 是课程 c 的先修课程,那么课程 a 也是课程 c 的先修课程。

    示例 1:

    输入:n = 2, prerequisites = [[1,0]], queries = [[0,1],[1,0]]
    输出:[false,true]
    解释:课程 0 不是课程 1 的先修课程,但课程 1 是课程 0 的先修课程。
    

    示例 2:

    输入:n = 2, prerequisites = [], queries = [[1,0],[0,1]]
    输出:[false,false]
    解释:没有先修课程对,所以每门课程之间是独立的。
    

    示例 3:

    输入:n = 3, prerequisites = [[1,2],[1,0],[2,0]], queries = [[1,0],[1,2]]
    输出:[true,true]
    

    示例 4:

    输入:n = 3, prerequisites = [[1,0],[2,0]], queries = [[0,1],[2,0]]
    输出:[false,true]
    

    示例 5:

    输入:n = 5, prerequisites = [[0,1],[1,2],[2,3],[3,4]], queries = [[0,4],[4,0],[1,3],[3,0]]
    输出:[true,false,true,false]
    

    提示:

    2 <= n <= 100
    0 <= prerequisite.length <= (n * (n - 1) / 2)
    0 <= prerequisite[i][0], prerequisite[i][1] < n
    prerequisite[i][0] != prerequisite[i][1]
    先修课程图中没有环。
    先修课程图中没有重复的边。
    1 <= queries.length <= 10^4
    queries[i][0] != queries[i][1]
    

    课程依赖是典型的拓扑排序题。这道题我们在拓扑序的基础上 BFS 就行。

    class Solution {
     public:
      vector<bool> checkIfPrerequisite(int n, vector<vector<int>>& prerequisites, vector<vector<int>>& queries) {
        vector<vector<int>>g(n);
        vector<int>ind(n, 0);
        for(auto i : prerequisites) {
          int u = i[0], v = i[1];
          ind[v]++;
          g[u].push_back(v);
        }
        vector<vector<bool> >ans(n, vector<bool>(n, false));
        queue<int>que;
        for(int i = 0; i < n; ++i)
          if(ind[i] == 0)
            que.push(i);
        while(!que.empty()) {
          int u = que.front();
          cout << u << " ";
          que.pop();
          BFS(u, g, ans);
          for(auto v : g[u]) {
            ind[v]--;
            if(ind[v] == 0)
              que.push(v);
          }
        }
        vector<bool>ret;
        for(auto i : queries) {
          int u = i[0], v = i[1];
          ret.push_back(ans[u][v]);
        }
        return ret;
      }
    
      void BFS(int s, vector<vector<int>> &g, vector<vector<bool>> &ans) {
        int u;
        queue<int>que;
        vector<bool>vis(100, false);
        que.push(s);
        while(!que.empty()) {
          u = que.front();
          que.pop();
          if(u != s)
            ans[s][u] = true;
          for(int v : g[u])
            if(!vis[v]) {
              que.push(v);
              vis[v] = true;
            }
        }
      }
    };
    

    5411. 摘樱桃 II

    给你一个 rows x cols 的矩阵 grid 来表示一块樱桃地。 grid 中每个格子的数字表示你能获得的樱桃数目。

    你有两个机器人帮你收集樱桃,机器人 1 从左上角格子 (0,0) 出发,机器人 2 从右上角格子 (0, cols-1) 出发。

    请你按照如下规则,返回两个机器人能收集的最多樱桃数目:

    从格子 (i,j) 出发,机器人可以移动到格子 (i+1, j-1)(i+1, j) 或者 (i+1, j+1)
    当一个机器人经过某个格子时,它会把该格子内所有的樱桃都摘走,然后这个位置会变成空格子,即没有樱桃的格子。
    当两个机器人同时到达同一个格子时,它们中只有一个可以摘到樱桃。
    两个机器人在任意时刻都不能移动到 grid 外面。
    两个机器人最后都要到达 grid 最底下一行。

    示例 1:

    输入:grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]]
    输出:24
    解释:机器人 1 和机器人 2 的路径在上图中分别用绿色和蓝色表示。
    机器人 1 摘的樱桃数目为 (3 + 2 + 5 + 2) = 12 。
    机器人 2 摘的樱桃数目为 (1 + 5 + 5 + 1) = 12 。
    樱桃总数为: 12 + 12 = 24 。
    

    示例 2:

    输入:grid = [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]]
    输出:28
    解释:机器人 1 和机器人 2 的路径在上图中分别用绿色和蓝色表示。
    机器人 1 摘的樱桃数目为 (1 + 9 + 5 + 2) = 17 。
    机器人 2 摘的樱桃数目为 (1 + 3 + 4 + 3) = 11 。
    樱桃总数为: 17 + 11 = 28 。
    

    示例 3:

    输入:grid = [[1,0,0,3],[0,0,0,3],[0,0,3,3],[9,0,3,3]]
    输出:22
    

    示例 4:

    输入:grid = [[1,1],[1,1]]
    输出:4
    

    提示:

    rows == grid.length
    cols == grid[i].length
    2 <= rows, cols <= 70
    0 <= grid[i][j] <= 100 
    

    常规的最后一题 DP。状态 i,j,k 三维表示在第 i 层,robot_1 在 j 位置,robot_2 在 k 位置,能够取到的最大值。

    我太菜了,现场没来得及写滚动数组。

    class Solution {
     public:
      struct sta {
        int first, second, third;
        bool operator<(const sta &another)const {
          if(first != another.first)
            return first < another.first;
          if(second != another.second)
            return second < another.second;
          return third < another.third;
        }
      };
      int cherryPickup(vector<vector<int>>& grid) {
        const int n = grid.size();
        const int m = grid[0].size();
        vector<vector<vector<int>>> f(n, vector<vector<int>>(m, vector<int>(m)));
        if(m != 1)
          f[0][0][m - 1] = grid[0][0] + grid[0][m - 1];
        else
          f[0][0][m - 1] = grid[0][0];
    
        queue<sta>que;
        map<sta, bool>vis;
        que.push({0, 0, m - 1});
        while(!que.empty()) {
          sta u = que.front();
          que.pop();
          vis[u] = false;
          if(u.first == n - 1)
            continue;
          for(int i = -1; i <= 1; ++i) {
            for(int j = -1; j <= 1; ++j) {
              sta nxt{u.first + 1, u.second + i, u.third + j};
              if(nxt.second < 0 || nxt.third < 0 || nxt.second >= m || nxt.third >= m)
                continue;
              int val;
              if(nxt.second != nxt.third) {
                val =  grid[nxt.first][nxt.third] + grid[nxt.first][nxt.second] + f[u.first][u.second][u.third];
                if(f[nxt.first][nxt.second][nxt.third] < val) {
                  f[nxt.first][nxt.second][nxt.third] = val;
                  if(!vis[nxt])
                    que.push(nxt), vis[nxt] = true;
                }
              } else {
                val = grid[nxt.first][nxt.third] + f[u.first][u.second][u.third];
                if(f[nxt.first][nxt.second][nxt.third] < val) {
                  f[nxt.first][nxt.second][nxt.third] = val;
                  if(!vis[nxt])
                    que.push(nxt), vis[nxt] = true;
                }
              }
            }
          }
        }
        int ans(0);
        for(int i = 0; i < m; ++i)
          for(int j = 0; j < m; ++j)
            ans = max(ans, f[n - 1][i][j]);
        return ans;
      }
    };
    
  • 相关阅读:
    一元运算符重载 前置和后置++ --(这种一般用成员函数来实现重载)
    运算符中的二元重载,为什么要调用友元函数而不是全局函数的问题
    关于数组的封装不知道为什么错了,具体代码如下
    关于对象的动态建立和释放
    关于构造函数中调用构造函数的危险
    关于析构函数,构造函数匿名对象的总结,以厚忘了,可以回来观看很全
    关于深拷贝和浅拷贝的疑问
    构造函数的调用大全
    构造函数的调用(其中不包括赋值构造函数)
    LeetCode:Add Digits
  • 原文地址:https://www.cnblogs.com/Forgenvueory/p/12995810.html
Copyright © 2011-2022 走看看