华为 OD 一面算法原题

宫水三叶的刷题日记2024-02-24 13:55

2.2 亿彩票公布调查结果

昨天，闹得沸沸扬扬的《10 万中 2.2 亿》的彩票事件，迎来了官方公告。

简单来说，调查结果就是：一切正常，合规合法。

关于福利彩票事件，之前的推文我们已经分析过。

甚至在后面出现《双色球 6.8 亿》事件时，还用类似的逻辑分析写了回答发到过某乎：

这次所谓调查通报，其实还是没有走出使用「公信力」来进行自证的圈子。

该说的都说过了，本次不再点评。

...

回归主线。

今天接着看「华为 OD」一面算法原题。

昨天分享了一道「子序列」相关的「华为 OD」一面算法原题，很多网友表示不可思议。

那道题在 LeetCode 中是 Hard，现在连 OD 都这么卷了吗？

是的，OD 都开始卷了。

这其实不难理解。

算法在笔试面试中出现，主要是起到一个「过滤」的作用。

以前面试算法题难度普遍没有很高，是因为出到普通难度，也足以产生过滤作用，再难可能就没有候选人做出来，反而起不到过滤效果。

现如今，随着互联网大厂的各种裁员，加上应届大学生毕业人数屡创新高，连华为 OD 岗位都供远大于求了，因此算法题难度也上来了。

题目描述

平台：LeetCode

题号：943

给定一个字符串数组 words，找到以 words 中每个字符串作为子字符串的最短字符串。

如果有多个有效最短字符串满足题目条件，返回其中任意一个即可。

我们可以假设 words 中没有字符串是 words 中另一个字符串的子字符串。

示例 1：

arduino 复制代码 
输入：words = ["alex","loves","leetcode"]

输出："alexlovesleetcode"

解释："alex"，"loves"，"leetcode" 的所有排列都会被接受。

示例 2：

ini 复制代码 
输入：words = ["catg","ctaagt","gcta","ttca","atgcatc"]

输出："gctaagttcatgcatc"

提示：

  • <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 < = w o r d s . l e n g t h < = 12 1 <= words.length <= 12 </math>1<=words.length<=12
  • <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 < = w o r d s [ i ] . l e n g t h < = 20 1 <= words[i].length <= 20 </math>1<=words[i].length<=20
  • words[i] 由小写英文字母组成
  • words 中的所有字符串互不相同

状压 DP

为了方便，将 words 记为 ws。

预处理二维数组 g 来表示字符串 ws[i] 和 ws[j] 的重叠部分的长度：若 g[i][j] = len 代表字符串 ws[i] 长度为 len 的后缀与字符串 ws[j] 长度为 len 的前缀相同。

另外用一个二进制数 status 来代表当前超级串 ans 对 ws 的使用（覆盖）情况：若 status 的第 i 位为 1 代表字符串 ws[i] 已被使用（即 ws[i] 已是 ans 的子串），若 status 的第 i 位为 0 代表 ws[i] 未被使用。

我们知道，当所有的 <math xmlns="http://www.w3.org/1998/Math/MathML"> g [ i ] [ j ] = 0 g[i][j] = 0 </math>g[i][j]=0 时，代表所有拼接方式长度均为 <math xmlns="http://www.w3.org/1998/Math/MathML"> ∑ i = 0 n − 1 w s [ i ] . l e n g t h \sum_{i = 0}^{n - 1}ws[i].length </math>∑i=0n−1ws[i].length，即不能通过产生重叠部分来缩短超级串的长度。

因此，最小化超级串 ans 的长度等价于最大化重叠部分的长度。

定义 <math xmlns="http://www.w3.org/1998/Math/MathML"> f [ s ] [ i ] f[s][i] </math>f[s][i] 代表当前状态为 s 且当前最后一个使用到的字符串为 ws[i] （当前超级串 ans 的结尾部分为 ws[i]）时的最大重合长度。

最终超级串的长度为所有字符串的总长度 <math xmlns="http://www.w3.org/1998/Math/MathML"> ∑ i = 0 n − 1 w s [ i ] . l e n g t h \sum_{i = 0}^{n - 1}ws[i].length </math>∑i=0n−1ws[i].length 减去最大重合长度 <math xmlns="http://www.w3.org/1998/Math/MathML"> max ⁡ ( f [ 2 n − 1 ] [ i ] ) \max(f[2^n - 1][i]) </math>max(f[2n−1][i])。

不失一般性考虑 <math xmlns="http://www.w3.org/1998/Math/MathML"> f [ s ] [ i ] f[s][i] </math>f[s][i] 可用于更新哪些状态，我们可枚举接在字符串 ws[i] 后面的字符串 ws[j] 为何值：

  1. 由于每个字符串只能使用一次，转移需要满足 s 的第 i 位为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1，s 的第 j 位为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 0 0 </math>0 的前提条件，含义为 ws[i] 已被使用，而 ws[j] 未被使用
  2. 满足前提条件 <math xmlns="http://www.w3.org/1998/Math/MathML"> 1 1 </math>1，代表 ws[j] 可接在 ws[i] 后面，此时有状态转移方程：
    <math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> f [ s ∣ ( 1 < < j ) ] [ j ] = f [ s ] [ i ] + g [ i ] [ j ] f[s | (1 << j)][j] = f[s][i] + g[i][j] </math>f[s∣(1<<j)][j]=f[s][i]+g[i][j]

接下来，考虑如何构建具体方案。

使用二维数组 <math xmlns="http://www.w3.org/1998/Math/MathML"> p [ s ] [ i ] p[s][i] </math>p[s][i] 记录每个状态是由哪个前驱转移而来 ：若有 <math xmlns="http://www.w3.org/1998/Math/MathML"> p [ s ] [ i ] = j p[s][i] = j </math>p[s][i]=j，代表取得最大重叠长度过程中，字符串 ws[j] 接在 ws[i] 后面。

我们从后往前对 ans 进行构造，若 ans = ws[0] + ws[1] + ... + ws[k - 1] + ws[k]，我们是先找 ws[k]，再通过 ws[k] 找 ws[k - 1]，直到将整个 ans 构建出来。

构造过程中使用变量解释如下：

  • ans 为具体的超级串
  • status 代表当前还有哪些字符串待拼接到，初始化为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 n − 1 2^n - 1 </math>2n−1，代表还没有任何字符串拼接到 ans 中
  • idx 代表当前处理到的字符串下标，初始化通过遍历所有的 <math xmlns="http://www.w3.org/1998/Math/MathML"> f [ 2 n − 1 ] [ i ] f[2^n - 1][i] </math>f[2n−1][i] 找到合适的 <math xmlns="http://www.w3.org/1998/Math/MathML"> i i </math>i 作为 idx
  • last 代表前一个处理到字符串下标，初始化为 -1

一些细节：当 last 不为初始值 -1 时，需要跳过 ws[idx] 与 ws[last] 的重复部分进行拼接。

Java 代码：

Java 复制代码 
class Solution {
  public String shortestSuperstring(String[] ws) {
      int n = ws.length, mask = 1 << n;
      int[][] g = new int[n][n];
      for (int i = 0; i < n; i++) {
          for (int j = 0; j < n; j++) {
              String a = ws[i], b = ws[j];
              int l1 = a.length(), l2 = b.length(), len = Math.min(l1, l2);
              for (int k = len; k >= 1; k--) {
                  if (a.substring(l1 - k).equals(b.substring(0, k))) {
                      g[i][j] = k;
                      break;
                  }
              }
          }
      }
      int[][] f = new int[mask][n], p = new int[mask][n];
      for (int s = 0; s < mask; s++) {
          for (int i = 0; i < n; i++) {
              if (((s >> i) & 1) == 0) continue;
              for (int j = 0; j < n; j++) {
                  if (((s >> j) & 1) == 1) continue;
                  if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {
                      f[s | (1 << j)][j] = f[s][i] + g[i][j];
                      p[s | (1 << j)][j] = i;
                  }
              }
          }
      }
      int max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;
      for (int i = 1; i < n; i++) {
          if (max < f[mask - 1][i]) {
              max = f[mask - 1][i];
              idx = i;
          }
      }
      String ans = "";
      while (status != 0) {
          if (last == -1) ans = ws[idx];
          else ans = ws[idx].substring(0, ws[idx].length() - g[idx][last]) + ans;
          last = idx;
          idx = p[status][idx];
          status ^= (1 << last);
      }
      return ans;
  }
}

Python 代码：

Python 复制代码 
class Solution:
  def shortestSuperstring(self, ws: List[str]) -> str:
      n, mask = len(ws), 1 << len(ws)
      g = [[0 for _ in range(n)] for _ in range(n)]
      for i in range(n):
          for j in range(n):
              a, b = ws[i], ws[j]
              l1, l2 = len(a), len(b)
              length = min(l1, l2)
              for k in range(length, 0, -1):
                  if a[l1 - k:] == b[:k]:
                      g[i][j] = k
                      break
      f = [[0 for _ in range(n)] for _ in range(mask)]
      p = [[0 for _ in range(n)] for _ in range(mask)]
      for s in range(mask):
          for i in range(n):
              if (s >> i) & 1 == 0:
                  continue
              for j in range(n):
                  if (s >> j) & 1 == 1:
                      continue
                  if f[s | (1 << j)][j] <= f[s][i] + g[i][j]:
                      f[s | (1 << j)][j] = f[s][i] + g[i][j]
                      p[s | (1 << j)][j] = i
      
      max_val = f[mask - 1][0]
      idx, last, status = 0, -1, mask - 1        
      for i in range(1, n):
          if max_val < f[mask - 1][i]:
              max_val = f[mask - 1][i]
              idx = i
      ans = ""
      while status != 0:
          if last == -1:
              ans = ws[idx]
          else:
              ans = ws[idx][:len(ws[idx]) - g[idx][last]] + ans
          last = idx
          idx = p[status][idx]
          status ^= 1 << last
      return ans

C++ 代码：

C++ 复制代码 
class Solution {
public:
  string shortestSuperstring(vector<string>& ws) {
int n = ws.size(), mask = 1 << n;
      vector<vector<int>> g(n, vector<int>(n, 0));
      for (int i = 0; i < n; i++) {
          for (int j = 0; j < n; j++) {
              string a = ws[i], b = ws[j];
              int l1 = a.length(), l2 = b.length(), len = min(l1, l2);
              for (int k = len; k >= 1; k--) {
                  if (a.substr(l1 - k) == b.substr(0, k)) {
                      g[i][j] = k;
                      break;
                  }
              }
          }
      }
      vector<vector<int>> f(mask, vector<int>(n, 0)), p(mask, vector<int>(n, 0));
      for (int s = 0; s < mask; s++) {
          for (int i = 0; i < n; i++) {
              if (((s >> i) & 1) == 0) continue;
              for (int j = 0; j < n; j++) {
                  if (((s >> j) & 1) == 1) continue;
                  if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {
                      f[s | (1 << j)][j] = f[s][i] + g[i][j];
                      p[s | (1 << j)][j] = i;
                  }
              }
          }
      }
      int max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;
      for (int i = 1; i < n; i++) {
          if (max < f[mask - 1][i]) {
              max = f[mask - 1][i];
              idx = i;
          }
      }
      string ans = "";
      while (status != 0) {
          if (last == -1) ans = ws[idx];
          else ans = ws[idx].substr(0, ws[idx].length() - g[idx][last]) + ans;
          last = idx;
          idx = p[status][idx];
          status ^= (1 << last);
      }
      return ans;
  }
};

TypeScript 代码：

TypeScript 复制代码 
function shortestSuperstring(ws: string[]): string {
  const n = ws.length, mask = 1 << n;
  const g = new Array(n).fill(0).map(() => new Array(n).fill(0));
  for (let i = 0; i < n; i++) {
      for (let j = 0; j < n; j++) {
          const a = ws[i], b = ws[j];
          const l1 = a.length, l2 = b.length;
          const len = Math.min(l1, l2);
          for (let k = len; k >= 1; k--) {
              if (a.substring(l1 - k) === b.substring(0, k)) {
                  g[i][j] = k;
                  break;
              }
          }
      }
  }
  const f = new Array(mask).fill(0).map(() => new Array(n).fill(0));
  const p = new Array(mask).fill(0).map(() => new Array(n).fill(0));
  for (let s = 0; s < mask; s++) {
      for (let i = 0; i < n; i++) {
          if (((s >> i) & 1) === 0) continue;
          for (let j = 0; j < n; j++) {
              if (((s >> j) & 1) === 1) continue;
              if (f[s | (1 << j)][j] <= f[s][i] + g[i][j]) {
                  f[s | (1 << j)][j] = f[s][i] + g[i][j];
                  p[s | (1 << j)][j] = i;
              }
          }
      }
  }
  let max = f[mask - 1][0], idx = 0, last = -1, status = mask - 1;
  for (let i = 1; i < n; i++) {
      if (max < f[mask - 1][i]) {
          max = f[mask - 1][i];
          idx = i;
      }
  }
  let ans = "";
  while (status != 0) {
      if (last === -1) ans = ws[idx];    
      else ans = ws[idx].substring(0, ws[idx].length - g[idx][last]) + ans;
      last = idx;
      idx = p[status][idx];
      status ^= (1 << last);
  }
  return ans;
}
  • 时间复杂度：将字符串 <math xmlns="http://www.w3.org/1998/Math/MathML"> w s [ i ] ws[i] </math>ws[i] 的最大长度记为 <math xmlns="http://www.w3.org/1998/Math/MathML"> C = 20 C = 20 </math>C=20，预处理复杂度为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n 2 × C ) O(n^2 \times C) </math>O(n2×C)；状态数量为 <math xmlns="http://www.w3.org/1998/Math/MathML"> 2 n 2^n </math>2n，DP 复杂度为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 2 n × n 2 ) O(2^n \times n^2) </math>O(2n×n2)。构造答案复杂度为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( n ) O(n) </math>O(n)。整体复杂度为 <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 2 n × n 2 ) O(2^n\times n^2) </math>O(2n×n2)
  • 空间复杂度： <math xmlns="http://www.w3.org/1998/Math/MathML"> O ( 2 n × n ) O(2^n \times n) </math>O(2n×n)

我是宫水三叶，每天都会分享算法知识，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉
<math xmlns="http://www.w3.org/1998/Math/MathML" display="block"> </math>

相关推荐
Martin -Tang5 分钟前
vite和webpack的区别
前端·webpack·node.js·vite
迷途小码农零零发6 分钟前
解锁微前端的优秀库
前端
王解1 小时前
webpack loader全解析，从入门到精通（10）
前端·webpack·node.js
我不当帕鲁谁当帕鲁1 小时前
arcgis for js实现FeatureLayer图层弹窗展示所有field字段
前端·javascript·arcgis
那一抹阳光多灿烂1 小时前
工程化实战内功修炼测试题
前端·javascript
放逐者-保持本心，方可放逐2 小时前
微信小程序=》基础=》常见问题=》性能总结
前端·微信小程序·小程序·前端框架
码上一元2 小时前
SpringBoot自动装配原理解析
java·spring boot·后端
毋若成4 小时前
前端三大组件之CSS，三大选择器，游戏网页仿写
前端·css
枫叶_v4 小时前
【SpringBoot】22 Txt、Csv文件的读取和写入
java·spring boot·后端
红中马喽4 小时前
JS学习日记（webAPI—DOM）
开发语言·前端·javascript·笔记·vscode·学习
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【Flutter】基于 GetX 实现 Dio 的生命周期自动化