力扣杯春赛-个人赛 LCCUP’23
LCP 72. 补给马车
关键词：模拟
题目来源：LCP 72. 补给马车 - 力扣（Leetcode）
题目描述
T模拟
远征队即将开启未知的冒险之旅，不过在此之前，将对补给车队进行最后的检查。supplies[i] 表示编号为 i 的补给马车装载的物资数量。 考虑到车队过长容易被野兽偷袭，他们决定将车队的长度变为原来的一半（向下取整），计划为：
- 找出车队中 物资之和最小 两辆 相邻 马车，将它们车辆的物资整合为一辆。若存在多组物资之和相同的马车，则取编号最小的两辆马车进行整合；
- 重复上述操作直到车队长度符合要求。
请返回车队长度符合要求后，物资的分布情况。
输入：supplies = [7,3,6,1,8]
输出：[10,15]
输入：supplies = [1,3,1,5]
输出：[5,5]
数据范围
2 <= supplies.length <= 1000
1 <= supplies[i] <= 1000
问题分析
观察数据范围，O(n^2)的时间复杂度是可以接受的，本题采用模拟即可。具体做法如下：
合并次数m=n-(n>>1)，对于每次合并
- 扫描一遍数组，找到和最小的相邻两个元素，设为i，j
- 执行合并操作，即a[i]+=a[j]；将j标记为不存在，即a[j]=0
最后，将剩余元素取出返回即可。
时间复杂度：O(n^2)
空间复杂度：O(n)
vector<int> supplyWagon(vector<int> &supplies) {
int n = supplies.size(), m = n - (n >> 1);
// m次合并
while (m--) {
// 找到和最小的相邻两个元素
int sum = INT_MAX, mi, mj;
for (int i = 0, j; i < n; i = j) {
// 相邻两个元素i和j
while (i < n && supplies[i] == 0)i++;
j = i + 1;
while (j < n && supplies[j] == 0)j++;
// 比较和
if (j < n && supplies[i] + supplies[j] < sum) {
sum = supplies[i] + supplies[j], mi = i, mj = j;
}
}
// 合并
supplies[mi] += supplies[mj], supplies[mj] = 0;
}
// 将剩余元素取出
vector<int> ans;
for (const auto &e: supplies) {
if (e != 0)ans.push_back(e);
}
return ans;
}
LCP 73. 探险营地
关键词：字典树、STL
题目来源：LCP 73. 探险营地 - 力扣（Leetcode）
问题描述
T字典树
TSTL
探险家小扣的行动轨迹，都将保存在记录仪中。expeditions[i] 表示小扣第 i 次探险记录，用一个字符串数组表示。其中的每个「营地」由大小写字母组成，通过子串 -> 连接。
例：“Leet->code->Campsite”，表示到访了 “Leet”、“code”、“Campsite” 三个营地。
expeditions[0] 包含了初始小扣已知的所有营地；对于之后的第 i 次探险(即 expeditions[i] 且 i > 0)，如果记录中包含了之前均没出现的营地，则表示小扣 新发现 的营地。
请你找出小扣发现新营地最多且索引最小的那次探险，并返回对应的记录索引。如果所有探险记录都没有发现新的营地，返回 -1
注意：
- 大小写不同的营地视为不同的营地；
- 营地的名称长度均大于
0。
输入：expeditions = ["leet->code","leet->code->Campsite->Leet","leet->code->leet->courier"]
输出：1
输入：expeditions = ["Alice->Dex","","Dex"]
输出：-1
输入：expeditions = ["","Gryffindor->Slytherin->Gryffindor","Hogwarts->Hufflepuff->Ravenclaw"]
输出：2
数据范围
1 <= expeditions.length <= 1000
0 <= expeditions[i].length <= 1000
探险记录中只包含大小写字母和子串"->"
问题分析
本题的核心问题就是：对于统计s[i]中有多少个“子串”没在s[0…1]中出现过。对于“查找字符串是否出现过”这类问题，很自然就想到字典树。若不采用字典树，可直接借助STL中的set。
字典树—数组
若采用字典树，对于本题而言，查询和插入可同时进行。
这里存在一个问题：N该指定多大呢？一般来说，最多有多少个结点，N就指定为多大，根据题目给出的数据范围，N应该为1e6（实际应比1e6稍大，避免越界），但是，这显然会超内存。经过测试，N大概可以到4e5，不会超内存且能通过本题，可以说，非常侥幸。
const int N = 4e5 + 5;
int son[N][52], n;
bool fg[N];
/**
* 查看字符串s是否存在，不存在则将其插入字典树中
*/
bool check(const string &s) {
int p = 0, u;
for (auto &c: s) {
u = c < 'a' ? c - 'A' : c - 'a' + 26;
if (!son[p][u])son[p][u] = ++n;
p = son[p][u];
}
if (fg[p])return true; // 已存在
fg[p] = true; // 标记已存在
return false; // 原先不存在
}
写好字典树相关的代码，后面只需要遍历统计就可以了。
/**
* 检查s中有多少子串还不存在
*/
int count(const string &s) {
int cnt = 0;
if (!s.empty()) {
int i, j;
for (i = 0, j = s.find('-'); j != string::npos; i = j + 2, j = s.find('-', i)) {
if (!check(s.substr(i, j - i))) cnt++;
}
if (!check(s.substr(i)))cnt++;
}
return cnt;
}
int adventureCamp(vector<string> &expeditions) {
// 将初始字符串插入字典树
count(expeditions[0]);
// 找到发现新营地最多的那次探险
int len = expeditions.size(), maxCam = 0, idx = -1, curCam;
for (int i = 1; i < len; i++) {
curCam = count(expeditions[i]);
if (curCam > maxCam)maxCam = curCam, idx = i;
}
return idx;
}
时间604 ms 内存120.4 MB
字典树—指针
前面采用数组的方式，需要预先指定数组大小，所以，我们可以采用指针，动态分配结点。
struct Node {
Node *child[52]{nullptr};
bool vis{false};
} *root;
/**
* 查看字符串s是否存在，不存在则将其插入字典树中
*/
bool check(const string &s) {
auto p = root;
int u;
for (const char &c: s) {
// 映射到0~52
u = c < 'a' ? c - 'A' : c - 'a' + 26;
if (p->child[u] == nullptr) {
p->child[u] = new Node();
}
p = p->child[u];
}
if (p->vis)return true; // 已存在
p->vis = true; // 标记已存在
return false; // s原先不存在
}
需要注意的是，采用指针的方式所占用的内存会比采用数组的方式多不少。
int count(const string &s){
// 同上
}
int adventureCamp(vector<string> &expeditions) {
// 同上
}
时间620 ms 内存529.3 MB
STL—set集合
本题的核心操作就是判断一个字符串是否存在，因此，可以直接利用set来存放已存在的的字符串
/**
* 检查s中有多少子串还不存在
*/
int count(const string &s) {
int cnt = 0;
if (!s.empty()) {
int i, j;
string ts;
for (i = 0, j = s.find('-'); j != string::npos; i = j + 2, j = s.find('-', i)) {
ts = s.substr(i, j - i);
if (st.find(ts) == st.end()) {
st.insert(ts), cnt++;
}
}
ts = s.substr(i);
if (st.find(ts) == st.end()) {
st.insert(ts), cnt++;
}
}
return cnt;
}
虽然这可以算作暴力做法，但无论是在时间还是在空间上，都远优于字典树。
int adventureCamp(vector<string> &expeditions) {
// 同上
}
时间316 ms 内存53.2 MB
LCP 74. 最强祝福力场
关键词：差分、前缀和、线段树、扫描线
题目来源：LCP 74. 最强祝福力场 - 力扣（Leetcode）
题目描述
T差分
T前缀和
T线段树
T扫描线
小扣在探索丛林的过程中，无意间发现了传说中“落寞的黄金之都”。而在这片建筑废墟的地带中，小扣使用探测仪监测到了存在某种带有「祝福」效果的力场。 经过不断的勘测记录，小扣将所有力场的分布都记录了下来。forceField[i] = [x,y,side] 表示第 i 片力场将覆盖以坐标 (x,y) 为中心，边长为 side 的正方形区域。
若任意一点的 力场强度 等于覆盖该点的力场数量，请求出在这片地带中 力场强度 最强处的 力场强度。
**注意：**力场范围的边缘同样被力场覆盖。
输入： forceField = [[0,0,1],[1,0,1]]
输出：2
输入： forceField = [[4,4,6],[7,5,3],[1,6,2],[5,6,3]]
输出：3
数据范围
1 <= forceField.length <= 100
forceField[i].length == 3
0 <= forceField[i][0], forceField[i][1] <= 10^9
1 <= forceField[i][2] <= 10^9
问题分析
粗略一看，本题需要用扫描线来做，但是，观察数据范围发现，正方形的数量较少，正方形可能很大，对于这种“量少值大”的情况，极有可能使用到离散化，而离散化通常又和前缀和/差分一起出现，于是思考，能否使用前缀和和差分来解决此题。
题目要求的是被覆盖次数最多的点的被覆盖次数，对于每个正方形而言，其可以使得范围内的所有点的被覆盖次数+1，朴素想法就是，就出所有点被覆盖的次数，求最大值，便是本题的答案。而将一个矩形范围内的元素统一进行+1操作，这正是二维差分所擅长的。
但是，本题的坐标值非常的大，因此需要将坐标离散化，且是有序离散化。那离散化会不会影响答案呢？
证明：离散化不影响答案
设点p为力场强度最强的点，则必然存在这样一个最小矩形，其包含点p，且矩形内所有的点的力场强度均相等。注意，这样的矩形不一定是题目所给的矩形，而是由题目所给矩形的边围成的矩形，且可能是一条线，且p可能在矩形边上。
于是，必然存在一点q，其力场强度是最强的，且位于某个题目所给矩形的边上。
设t是题目所给的任意矩形的任意边上的任意一点，进行有序离散化后：
- 原本在yt下边的横线仍在yt下边
- 原来在yt上边的横线仍在yt上边
- 原来在xt左边的竖线仍在xt左边
- 原来在xt右边的竖线仍在xt右边
也即，点t被覆盖的次数并没有变，而对于其余非边上点，进行离散化后已全部被剔除，故最终的答案不变，证毕。
时间复杂度：O(n^2)
空间复杂度：O(n^2)
代码实现
注意int溢出问题
typedef long long ll;
const int N = 2e2 + 5;
ll x[N], y[N];
int g[N][N], nx, ny;
/**
* 离散化（从1开始）
*/
int find(ll u, bool isX) {
return isX ?
lower_bound(x, x + nx, u) - x + 1
:
lower_bound(y, y + ny, u) - y + 1;
}
int fieldOfGreatestBlessing(vector<vector<int>> &forceField) {
int n = forceField.size();
// 记录所有出现的x坐标、y坐标
for (int i = 0; i < n; i++) {
auto &v = forceField[i];
v[0] <<= 1, v[1] <<= 1;
x[i << 1] = v[0] - v[2], x[i << 1 | 1] = (ll) v[0] + v[2];
y[i << 1] = v[1] - v[2], y[i << 1 | 1] = (ll) v[1] + v[2];
}
// 排序去重
n <<= 1;
sort(x, x + n), sort(y, y + n);
nx = unique(x, x + n) - x, ny = unique(y, y + n) - y;
// 二维差分
int x1, y1, x2, y2;
for (auto &v: forceField) {
// 离散化
x1 = find(v[0] - v[2], true);
x2 = find((ll) v[0] + v[2], true);
y1 = find(v[1] - v[2], false);
y2 = find((ll) v[1] + v[2], false);
// 差分
g[x1][y1]++, g[x2 + 1][y2 + 1]++;
g[x1][y2 + 1]--, g[x2 + 1][y1]--;
}
// 找到被覆盖最多的点
int maxCover = 0;
for (int i = 1; i <= nx; i++) {
for (int j = 1; j <= ny; j++) {
g[i][j] += g[i - 1][j] + g[i][j - 1] - g[i - 1][j - 1];
maxCover = max(g[i][j], maxCover);
}
}
return maxCover;
}
LCP 75. 传送卷轴
关键词：单源最短路、深度优先、广度优先
题目来源：LCP 75. 传送卷轴 - 力扣（Leetcode）
题目描述
T单源最短路
T深度优先
T广度优先
随着不断的深入，小扣来到了守护者之森寻找的魔法水晶。首先，他必须先通过守护者的考验。
考验的区域是一个正方形的迷宫，maze[i][j] 表示在迷宫 i 行 j 列的地形：
- 若为
.，表示可以到达的空地； - 若为
#，表示不可到达的墙壁； - 若为
S，表示小扣的初始位置； - 若为
T，表示魔法水晶的位置。
小扣每次可以向 上、下、左、右 相邻的位置移动一格。而守护者拥有一份「传送魔法卷轴」，使用规则如下：
- 魔法需要在小扣位于 空地 时才能释放，发动后卷轴消失；；
- 发动后，小扣会被传送到水平或者竖直的镜像位置，且目标位置不得为墙壁；
在使用卷轴后，小扣将被「附加负面效果」，因此小扣需要尽可能缩短传送后到达魔法水晶的距离。而守护者的目标是阻止小扣到达魔法水晶的位置；如果无法阻止，则尽可能 增加 小扣传送后到达魔法水晶的距离。 假设小扣和守护者都按最优策略行事，返回小扣需要在 「附加负面效果」的情况下 最少 移动多少次才能到达魔法水晶。如果无法到达，返回 -1。
注意：
- 守护者可以不使用卷轴；
- 传送后的镜像位置可能与原位置相同。
输入：maze = [".....","##S..","...#.","T.#..","###.."]
输出：7
解释：守护者释放魔法的两个最佳的位置为 [2,0] 或 [3,1]： 若小扣经过 [2,0]，守护者在该位置释放魔法， 小扣被传送至 [2,4] 处且加上负面效果，此时小扣还需要移动 7 次才能到达魔法水晶； 若小扣经过 [3,1]，守护者在该位置释放魔法， 小扣被传送至 [3,3] 处且加上负面效果，此时小扣还需要移动 9 次才能到达魔法水晶； 因此小扣负面效果下最少需要移动 7 次才能到达魔法水晶。
输入：maze = [".#..","..##",".#S.",".#.T"]
输出：-1
解释： 若小扣向下移动至 [3,2]，守护者使其传送至 [0,2]，小扣将无法到达魔法水晶； 若小扣向右移动至 [2,3]，守护者使其传送至 [2,0]，小扣将无法到达魔法水晶；
输入：maze = ["S###.","..###","#..##","##..#","###.T"]
输出：5
解释：守护者需要小扣在空地才能释放，因此初始无法将其从 [0,0] 传送至 [0,4]; 当小扣移动至 [2,1] 时，释放卷轴将其传送至水平方向的镜像位置 [2,1]（为原位置） 而后小扣需要移动 5 次到达魔法水晶
数据范围
4 <= maze.length == maze[i].length <= 200
maze[i][j] 仅包含 "."、"#"、"S"、"T"
问题分析
不难发现
- 若在 「附加负面效果」的情况下移动不超过k步能到达魔法水晶，在不超过k+1步也能到达终点
- 若在 「附加负面效果」的情况下移动不超过k步不能到达魔法水晶，在不超过k-1步也不能到达终点
因此k值具有单调性，可二分求解满足条件的k的最小值。
check(k)的任务就是，判断能否在 「附加负面效果」的情况下移动不超过k步到达魔法水晶，“是否存在通路”这类问题可采用dfs来做。
施加魔法后，需要直到新位置到达终点最少需要多少步，因此需要预处理出终点到每个位置的最短距离，“求最短通路”可采用bfs来做。
综上：bfs预处理出终点到每个点的最短距离，整体框架是二分，通过dfs判断是否存在通路。
时间复杂度：O( n2log(n) )
空间复杂度：O( n2 )
代码实现
typedef pair<int, int> P;
const int N = 2e2 + 5, INF = 0x3f3f3f3f;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
P s, t;
int n, d[N][N];
bool vis[N][N];
/**
* 初始化每个点到终点的最短距离
*/
void initDis(vector<string> &maze) {
memset(d, 0x3f, sizeof d);
queue<P> q;
int sep = d[t.first][t.second] = 0, u, v, lay;
q.push(t);
while (!q.empty()) {
// 每遍历一层，与终点的距离便+1
sep++, lay = q.size();
// 当前层所有结点与终点的距离均为sep
while (lay--) {
// 取出队头结点
P tp = q.front();
// 拓展结点
for (int i = 0; i < 4; i++) {
u = tp.first + dx[i], v = tp.second + dy[i];
if (u < 0 || u >= n || v < 0 || v >= n ||
maze[u][v] == '#' || d[u][v] < INF
)
continue;
if (u >= n || v >= n) {
cout << "!!!";
}
d[u][v] = sep;
q.push({u, v});
}
// 前面使用引用，所以要等到使用完后出队
q.pop();
}
}
}
/**
* 检查能否使得附加负面效果的步数不超过sep步到达终点
*/
bool dfs(int sep, int x, int y, vector<string> &maze) {
// 越界或障碍物或已访问
if (x < 0 || x >= n || y < 0 || y >= n ||
maze[x][y] == '#' || vis[x][y]
)
return false;
// 到达终点
if (x == t.first && y == t.second)return true;
if (x >= n || y >= n) {
cout << "!!!";
}
// 标记已访问
vis[x][y] = true;
// 施展魔法
// 体现守护者的最优策略
if (maze[x][y] == '.') {
// 如果能传送到一个使用sep不能到达终点的点，说明当前路在限制为sep的情况下不可
if (maze[x][n - y - 1] != '#' && d[x][n - y - 1] > sep)return false;
if (maze[n - x - 1][y] != '#' && d[n - x - 1][y] > sep)return false;
}
// 只要存在一条路在施加负面效果的情况下可在sep步内到达终点，说明sep步一定可到达终点
// 体现小扣的最优策略
for (int i = 0; i < 4; i++)
if (dfs(sep, x + dx[i], y + dy[i], maze))return true;
return false;
}
int challengeOfTheKeeper(vector<string> &maze) {
n = maze.size();
// 找到起点和终点
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (maze[i][j] == 'S')s = {i, j};
else if (maze[i][j] == 'T')t = {i, j};
// 初始化每个点到终点的最短距离
initDis(maze);
// 起点无法到达终点
if (d[s.first][s.second] >= INF)return -1;
// 二分答案
int l = 0, r = n * n, mid;
while (l < r) {
mid = (l + r) >> 1;
memset(vis, 0, sizeof vis);
if (dfs(mid, s.first, s.second, maze))r = mid;
else l = mid + 1;
}
return l == n * n ? -1 : l;
}
LCP 76. 魔法棋盘
关键词：深度优先、状态压缩
在大小为 n * m 的棋盘中，有两种不同的棋子：黑色，红色。当两颗颜色不同的棋子同时满足以下两种情况时，将会产生魔法共鸣：
- 两颗异色棋子在同一行或者同一列
- 两颗异色棋子之间恰好只有一颗棋子
注：异色棋子之间可以有空位
由于棋盘上被施加了魔法禁制，棋盘上的部分格子变成问号。chessboard[i][j] 表示棋盘第 i 行 j 列的状态：
- 若为
.，表示当前格子确定为空 - 若为
B，表示当前格子确定为 黑棋 - 若为
R，表示当前格子确定为 红棋 - 若为
?，表示当前格子待定
现在，探险家小扣的任务是确定所有问号位置的状态（留空/放黑棋/放红棋），使最终的棋盘上，任意两颗棋子间都 无法 产生共鸣。请返回可以满足上述条件的放置方案数量。
输入：n = 3, m = 3, chessboard = ["..R","..B","?R?"]
输出：5
输入：n = 3, m = 3, chessboard = ["?R?","B?B","?R?"]
输出：105
数据范围
n == chessboard.length
m == chessboard[i].length
1 <= n*m <= 30
chessboard 中仅包含 "."、"B"、"R"、"?"
问题分析
考虑到数据范围较小，因此，可采用深搜来枚举每种方案。
对于位置(i,j)
- 若为?，则将将其置为空/黑棋/红棋，放置是否合法，需要参考目前棋盘的状态
- 若为.，则直接往后深搜即可，因为空位不影响结果。
- 若为B或R，则需要判断目前的状态是否合法，若合法则往后深搜
从左往右从上到下的顺序（先列后行）搜索，每当搜完最后一个位置，便得到一种方案。
如何存放当前的状态呢？由于状态较多，一来要有助于快速判断是否合法，二来要节约空间，自然就想到状态压缩。
对于每一行/每一列，其合法的状态不外乎以下7类：
- 空：即全为“.”
- 仅一个B：如，“…B”，“…B…”
- 仅一个R：如，“.R…”，“R.”
- 多个B：如，“.B…B”，“…BB”
- 多个R：如，“RR…”，“R…RR…R”
- BR交替且结尾为B：如，“BRB…”，“…RB…”
- BR交替且结尾为R：如，“RB…R…BR”，“…R…B…R…”
故可用3位二进制来表示所有合法的单行/列状态。
对于?，由于将其置空不影响状态，故只需考虑置黑棋和置红棋的情况，于是，可以预处理出一张状态转换表T，借助表T，可快速判断是否合法。
由于位置(i,j)能放什么，是否合法，仅与所在行和所在列有关，且按从左往右从上到下，故需要记录当前行和所有列的信息。每列用3位二进制表示，且可以保证列数不超过5，故可用15位二进制表示所有列的状态，也即一个整数即可。
代码实现
不带记忆化：能过大部分测试用例
typedef pair<int, int> P;
const int N = 35;
char g[N][N];
int rn, cm;
long long ans;
// 状态转换表
int T[7][2] = {
// +B后的状态 +R后的状态
{1, 2}, // 空
{3, 6}, // 一个B
{5, 4}, // 一个R
{3, -1}, // 多个B
{-1, 4}, // 多个R
{-1, 6}, // BR交替且以B结尾
{5, -1} // BR交替且以R结尾
};
/**
* 枚举(i,j)的所有可能值
* rs：当前行的状态
* state：0~2位存放第1列的状态，3~5位存放第2列的状态，12~14位存放第5列的状态
*/
void dfs(int r, int c, int rs, int state) {
// 最后一行的状态已被枚举完：得到一种方案
if (r == rn) {
ans++;
return;
}
// 当前行已枚举完，开始枚举下一行
if (c == cm) {
dfs(r + 1, 0, 0, state);
return;
}
// 存放下一状态
P p = {rs, state};
// 检查在(r,c)追加颜色为C的棋是否合理，合理则将新的状态保存到p中
auto check = [&](int C) {
int c3 = c * 3;
if (T[rs][C] == -1 || T[(state >> c3) & 7][C] == -1)return false;
p = {T[rs][C], state & ~(7 << c3) | (T[(state >> c3) & 7][C] << c3)};
return true;
};
// 问号
if (g[r][c] == '?') {
// ?置为空：当前行和全局列的状态不改变
dfs(r, c + 1, rs, state);
// ?置为B
if (check(0))dfs(r, c + 1, p.first, p.second);
// ?置为R
if (check(1))dfs(r, c + 1, p.first, p.second);
return;
}
// 黑棋或红棋：判断是否与已经填充的冲突
else if (
g[r][c] == 'B' && !check(0) ||
g[r][c] == 'R' && !check(1)
)
return;
// 空位||(黑棋或红棋合理)
// 若为空位，则p就为初始状态
// 若为黑棋或红棋合理，则p在check时就已被修改为新的状态
dfs(r, c + 1, p.first, p.second);
}
long long getSchemeCount(int n, int m, vector<string> &chessboard) {
// 确保m≤n
if (n >= m) {
rn = n, cm = m;
for (int i = 0; i < n; i++)
sscanf(chessboard[i].c_str(), "%s", g[i]);
} else {
rn = m, cm = n;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
g[j][i] = chessboard[i][j];
}
// 深搜
dfs(0, 0, 0, 0);
return ans;
}
带记忆化：能AC
typedef long long ll;
typedef pair<int, int> P;
const int N = 32, M = 28087;
char g[N][N];
int rn, cm;
ll f[N][8][M];
// 状态转换表
int T[7][2] = {
// +B后的状态 +R后的状态
{1, 2}, // 空
{3, 6}, // 一个B
{5, 4}, // 一个R
{3, -1}, // 多个B
{-1, 4}, // 多个R
{-1, 6}, // BR交替且以B结尾
{5, -1} // BR交替且以R结尾
};
/**
* 枚举(i,j)的所有可能值
* rs：当前行的状态
* state：0~2位存放第1列的状态，3~5位存放第2列的状态，12~14位存放第5列的状态
* 返回目前状态为rs和state的情况下，从(i,j)开始枚举，得到的方案数
*/
ll dfs(int r, int c, int rs, int state) {
// 最后一行的状态已被枚举完：得到一种方案
if (r == rn) return 1;
// 当前行已枚举完，开始枚举下一行
if (c == cm)
return dfs(r + 1, 0, 0, state);
// 记忆化
ll &v = f[r * cm + c][rs][state];
if (v != -1)return v;
// 存放下一状态
P p = {rs, state};
// 检查在(r,c)追加颜色为C的棋是否合理，合理则将新的状态保存到p中
auto check = [&](int C) {
int c3 = c * 3;
if (T[rs][C] == -1 || T[(state >> c3) & 7][C] == -1)return false;
p = {T[rs][C], state & ~(7 << c3) | (T[(state >> c3) & 7][C] << c3)};
return true;
};
// 问号
if (g[r][c] == '?') {
v = 0;
// ?置为空：当前行和全局列的状态不改变
v += dfs(r, c + 1, rs, state);
// ?置为B
if (check(0))v += dfs(r, c + 1, p.first, p.second);
// ?置为R
if (check(1))v += dfs(r, c + 1, p.first, p.second);
return v;
}
// 黑棋或红棋：判断是否与已经填充的冲突
else if (
g[r][c] == 'B' && !check(0) ||
g[r][c] == 'R' && !check(1)
)
return v=0;
// 空位||(黑棋或红棋合理)
// 若为空位，则p就为初始状态
// 若为黑棋或红棋合理，则p在check时就已被修改为新的状态
return v = dfs(r, c + 1, p.first, p.second);
}
long long getSchemeCount(int n, int m, vector<string> &chessboard) {
// 确保m≤n
if (n >= m) {
rn = n, cm = m;
for (int i = 0; i < n; i++)
sscanf(chessboard[i].c_str(), "%s", g[i]);
} else {
rn = m, cm = n;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
g[j][i] = chessboard[i][j];
}
// 深搜
memset(f, -1, sizeof f);
return dfs(0, 0, 0, 0);;
}
扫一扫
2826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
