先分联通块,左边或者右边,可以接起来如下图:
XX..
.X..
XX..
....
XX..
.X..
第5行可以接起来第3行,成为一个,这个可以用贪心搞定
.....
XXXXX
.....
XX...
.XXXX
但是上面这种第二行就不知道哪边是头哪边是尾,所以用dp两种决策
dp[i][j][k],dp到第i行,左边可以有j个接上面的,右边有k个
几个trick:
....
X...
X...
....
X...
X...
这个不能接
.....
X....
.....
X....
这个也不行
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
using namespace std;
class Tunnels {
public:
int minimumTunnels(vector<string> );
};
bool visited[55][55];
int id[55][55];
int di, dj;
int n, m;
vector<string> s;
int dir[4][2] = { 1, 0, 0, 1, -1, 0, 0, -1 };
void dfs(int i, int j) {
int k;
visited[i][j] = true;
for (k = 0; k < 4; ++k) {
int ii = i + dir[k][0];
int jj = j + dir[k][1];
if (ii < 0 || jj < 0 || ii >= n || jj >= m)
continue;
if (s[ii][jj] == 'X' && visited[ii][jj] == false) {
dfs(ii, jj);
break;
}
}
if (k == 4) {
di = i;
dj = j;
}
}
int dp[55][55][55];
int Tunnels::minimumTunnels(vector<string> ss) {
int i, j, k;
int ans = 0;
s = ss;
n = s.size();
m = s[0].size();
if (m == 1) {
for (i = 0; i < n; ++i)
if (s[i][0] == 'X')
return 1;
return 0;
}
memset(visited, 0, sizeof(visited));
memset(id, 0, sizeof(id));
for (j = 1; j < m - 1; ++j) {
if (s[0][j] != 'X')
continue;
int cnt = 0;
if (s[0][j - 1] == 'X')
cnt++;
if (s[0][j + 1] == 'X')
cnt++;
if (n != 1 && s[1][j] == 'X')
cnt++;
if (cnt <= 1 && visited[i][j] == false) {
ans++;
dfs(0, j);
id[di][dj] |= 2;
}
}
for (i = 0; i < n; ++i) {
j = 0;
if (s[i][j] == 'X' && visited[i][j] == false) {
int cnt = 0;
if (s[i][j + 1] == 'X')
cnt++;
if (i != n - 1 && s[i + 1][j] == 'X')
cnt++;
if (cnt != 2) {
dfs(i, j);
if (dj == m - 1 && di == i) {
id[i][j] = id[di][dj] = -1;
} else {
id[i][j] |= 1;
id[di][dj] |= 2;
}
}
}
j = m - 1;
if (s[i][j] == 'X' && visited[i][j] == false) {
dfs(i, j);
id[i][j] |= 1;
id[di][dj] |= 2;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
for (k = 0; k < n; ++k) {
if (dp[i][j][k] == -1)
continue;
int jj, kk, add;
if (id[i][0] == id[i][m - 1] && id[i][m - 1] == -1) {
add = 0;
if (j > 0)
jj = j - 1;
else {
jj = j;
add++;
}
kk = k + 1;
if (dp[i + 1][jj][kk] == -1 || dp[i + 1][jj][kk]
> dp[i][j][k] + add)
dp[i + 1][jj][kk] = dp[i][j][k] + add;
add = 0;
if (k > 0)
kk = k - 1;
else {
kk = k;
add++;
}
jj = j + 1;
if (dp[i + 1][jj][kk] == -1 || dp[i + 1][jj][kk]
> dp[i][j][k] + add)
dp[i + 1][jj][kk] = dp[i][j][k] + add;
} else {
add = 0;
jj = j;
kk = k;
if (id[i][0] & 1) {
if (j > 0)
jj--;
else {
add++;
}
}
if (id[i][0] & 2) {
if (i == 0 || (id[i][0] == 2 && id[i - 1][0] != 1))
jj++;
if (i == 1 && (id[i][0] == 2 && id[i - 1][0] == 1))
jj++;
}
if (id[i][m - 1] & 1) {
if (k > 0)
kk--;
else {
add++;
}
}
if (id[i][m - 1] & 2) {
if (i == 0 || (id[i][m - 1] == 2 && id[i - 1][m - 1]
!= 1))
kk++;
if (i == 1 && (id[i][m - 1] == 2 && id[i - 1][m - 1]
== 1))
kk++;
}
if (dp[i + 1][jj][kk] == -1 || dp[i + 1][jj][kk]
> dp[i][j][k] + add)
dp[i + 1][jj][kk] = dp[i][j][k] + add;
}
}
}
}
int p = 1000000000;
for (j = 0; j <= n; ++j) {
for (k = 0; k <= n; ++k) {
if (dp[n][j][k] != -1)
p = min(p, dp[n][j][k]);
}
}
return ans + p;
}