---

题目

原题链接

题目描述

司令部的将军们打算在 $N\times M$ 的网格地图上部署他们的炮兵部队。

一个 $N\times M$ 的地图由 $N$ 行 $M$ 列组成，地图的每一格可能是山地（用 $\text{H}$ 表示），也可能是平原（用 $\text{P}$ 表示），如下图。

在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示：

如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。

图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。

现在，将军们规划如何部署炮兵部队，在防止误伤的前提下（保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内），在整个地图区域内最多能够摆放多少我军的炮兵部队。

输入格式

第一行包含两个由空格分割开的正整数，分别表示 $N$ 和 $M$。

接下来的 $N$ 行，每一行含有连续的 $M$ 个字符，按顺序表示地图中每一行的数据。

输出格式

一行一个整数，表示最多能摆放的炮兵部队的数量。

样例 #1

样例输入 #1

5 4
PHPP
PPHH
PPPP
PHPP
PHHP

样例输出 #1

6

提示

对于 $100\%$ 的数据，$1\le N\le 100$，$1\le M\le 10$，保证字符仅包含 P 与 H。

解题思路

分析

由于每一行都受上两行的状态的影响，所以我们需要开三维数组。
我们令 $1$ 表示此地放了阵地，$0$ 则表示没有。
定义 $f[i][s][s1]$ 表示当前在第 $i$ 行，本行状态为 $s$，上一行状态为 $s1$ 时最多有几个阵地。
则循环枚举，有：

f[i][s][s1]=max(f[i][s][s1],f[i-1][s1][s2]+a[s]);

其中 $s2$ 为上两行状态，$a[s]$ 表示当状态为 $s$ 时放了几个阵地。
但必须满足：

1. 状态 $s,s1,s2$ 均是合法状态。
2. $s2$ 不影响 $s,s1$，$s1$ 不影响 $s$。

所以纯暴力的代码就已经出来了，不过：
时间复杂度：$O(n{m}^2{8}^m)$
空间复杂度：$O(n{4}^m)$
好吧，根本不会炸。

考虑优化：

1. 对于每个 $a[i]$，可以预处理解决。
2. 对于每个状态 $s$ 本身是否合法可以预处理。
3. 对于每个状态 $s$ 的下一行有几个合法状态可以预处理。
4. 对于每个地形，可以用二进制来表示，$1$ 为山地，$0$ 为平地。判断是 & 一下就行了。
5. 第一维的 $i$ 可以滚动掉。

对于 1：
很简单：

inline int ga(int x)
{
	int cnt=0;
	while(x>0)
	{
		if(x&1)
			cnt++;
		x>>=1;
	}
	return cnt;
}

对于 2：

inline bool check(int x)
{
	return !(((x>>2)&x)|(x&(x>>1)));
}
	for(int i=0;i<(1<<m);i++)
		if(check(i))
			s.push_back(i);

即每两个 $1$ 之间至少隔两个 $0$。
对于 3：

	int len=s.size();
	for(int i=0;i<len;i++)
		for(int j=0;j<len;j++)
			if(!(s[i]&s[j]))
				Q[s[i]].push_back(s[j]);

对于 4：
同样很简单：

for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cin>>c;
			g[i]=(g[i]<<1)+(c=='H');
		}
	}

Code

 #include<bits/stdc++.h>
#define int long long
#define IOS ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL);
using namespace std;
const int N=1<<10;
vector<int>s;
vector<int>Q[N];
int n,m,f[101][N][N],g[200],a[N];
char c;
inline bool check(int x)
{
	return !(((x>>2)&x)|(x&(x>>1)));
}
inline int ga(int x)
{
	int cnt=0;
	while(x>0)
	{
		if(x&1)
			cnt++;
		x>>=1;
	}
	return cnt;
}
signed main()
{
	IOS;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cin>>c;
			g[i]=(g[i]<<1)+(c=='H');
		}
	}
	for(int i=0;i<(1<<m);i++)
		if(check(i))
			s.push_back(i),a[i]=ga(i);
	int len=s.size();
	for(int i=0;i<len;i++)
		for(int j=0;j<len;j++)
			if(!(s[i]&s[j]))
				Q[s[i]].push_back(s[j]);
	int Y=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=0;j<len;j++)
		{	
			Y++;
			int S=s[j];
			if(!(g[i]&S))
			{
				int L=Q[S].size();
				for(int k=0;k<L;k++)
				{
					int S1=Q[S][k];
					int Le=Q[S1].size();
					for(int u=0;u<Le;u++)
					{
						int S2=Q[S1][u];
						if((S&S2)||(S1&g[i-1])||(S2&g[i-2]))
							continue;
						f[i][S][S1]=max(f[i][S][S1],f[i-1][S1][S2]+a[S]);
					}
				}
			}
		}
	}
	int ans=0;
	for(int i=0;i<len;i++)
		for(int j=0;j<Q[s[i]].size();j++)
			ans=max(ans,f[n][s[i]][Q[s[i]][j]]);
	cout<<ans;
	return 0;
}

空间复杂度：$O(4^m)$
时间复杂度：$O(n{8}^m)$

而由于优化过后了，时间复杂度远远跑不满，实际复杂度约为：$O(60\times [20,40{]}^2\times n)$

更多方法

更多方法