我用的是 floyd. (虽然我感觉爆搜能过)
```cpp
#include <bits/stdc++.h>
using namespace std;

const int maxn = 25, INF = 0x3f3f3f3f;
string s[maxn];
int n, m, res = INF, dp[maxn][maxn][maxn][maxn];
int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};

int main() {
ios::sync_with_stdio(false);
memset(dp, INF, sizeof(dp));
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
dp[i][j][i][j] = 0;
for (int k = 0; k < 4; k++) {
int x = i + dx[k], y = j + dy[k];
if (x >= 0 && x < n && y >= 0 && y < m) {
dp[i][j][x][y] = (s[i][j] != s[x][y]);
}
}
}
}
// floyd
for (int kx = 0; kx < n; kx++) {
for (int ky = 0; ky < m; ky++) {
for (int ix = 0; ix < n; ix++) {
for (int iy = 0; iy < m; iy++) {
for (int jx = 0; jx < n; jx++) {
for (int jy = 0; jy < m; jy++) {
dp[ix][iy][jx][jy] = min(dp[ix][iy][jx][jy], dp[ix][iy][kx][ky] + dp[kx][ky][jx][jy]);
}
}
}
}
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
res = min(res, dp[0][i][n - 1][j]);
}
}
cout << res + 1 << endl;
return 0;
}
```

/*
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水水题题题题水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水水题题题题题水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水水题题题题题题水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水题题题题题题水水水水水水水水水水水水水水水水水水题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水题题题题题题题题题题水水题题题水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水题题题题题题水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题水水水水题题题题题水水水水水水水水水水题题题题题题题题题题题题题题题水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题水水水水题题题题题题题水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水题题题题题题题水水水水题题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水题题题题题题题水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水题题题题题题题题题题题题题题题题题题题题题水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题水水水题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水水题题题题题题题题题题题题题题题题题题水题题题题题水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水题题题题题水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水题题题题题题水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水题题题题题题水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水题题题题题题题水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水题题题题题题题题水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水题题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水题题题题题题题题题水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水题题题题题题题题题题水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水题题题题题题题题题题题水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题水题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题水水题题题题题题题题题题水水水水题题题题题题题题题水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水题题题题水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水题题题题题水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水水水水水水水水水水题题题题题题水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水题题题题题题题水题题题题题题题题题水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水题题题水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水题题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水题题题题题题题题题题题题题水题题题题题题题题题题题题水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水题题题题题题题题题题题水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水题题题题题题题题题题水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题水水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水题题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题水水水水水水水水水水水水水水题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水题题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水题题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水题题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水题题题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水题题题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
水水水水水水水水水水水水水水水水水题题题题题题水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水水
*/

注意自己到自己为0，不然只有一行的话就不行。

#include <cstdio>
//#define debug

int n,m;
char type[25][25];
int map[450][450];

void read(){
scanf("%d%d",&m,&n);
for(int i=0;i<m;i++)
for(int j=0;j<n;j++){
scanf("%c",&type[i][j]);
if(type[i][j]=='\n')
scanf("%c",&type[i][j]);
}
}

void init(){
for(int i=0;i<440;i++)
for(int j=0;j<440;j++)
map[i][j]=6666666;

for(int i=0;i<440;i++)
map[i][i]=0;
}

void chk(int a,int i,int j){//距离

//右边
if(type[i][j]==type[i][j+1]&&j+1<n)
map[a][a+1]=map[a+1][a]=0;
else if(type[i][j]!=type[i][j+1]&&j+1<n)
map[a][a+1]=map[a+1][a]=1;

//左边
if(type[i][j]==type[i][j-1]&&j-1>=0)
map[a][a-1]=map[a-1][a]=0;
else if(type[i][j]!=type[i][j-1]&&j-1>=0)
map[a][a-1]=map[a-1][a]=1;

//上边
if(type[i][j]==type[i-1][j]&&i-1>=0)
map[a][a-n]=map[a-n][a]=0;
else if(type[i][j]!=type[i-1][j+1]&&i-1>=0)
map[a][a-n]=map[a-n][a]=1;

//下边
if(type[i][j]==type[i+1][j]&&i-1<m)
map[a][a+n]=map[a+n][a]=0;
else if(type[i][j]!=type[i+1][j+1]&&i-1<m)
map[a][a+n]=map[a+n][a]=1;

}

int main(){
#ifdef debug
freopen("in.txt","r",stdin);
#endif

init();
read();

for(int i=0;i<m;i++)
for(int j=0;j<n;j++){
int a=i*n+j;
chk(a,i,j);
}

for(int k=0;k<m*n;k++)
for(int i=0;i<=m*n;i++)
for(int j=0;j<=m*n;j++)
if(map[i][j]>map[i][k]+map[k][j])
map[i][j]=map[i][k]+map[k][j];

int minn=66666666;

for(int i=(m-1)*n;i<m*n;i++)
for(int f=0;f<n;f++){
int now=map[i][f];
minn=minn<now?minn:now;
}

printf("%d",minn+1);
return 0;
}

这题也太水了 数据也水的要死

用cnt作为点的编号
4行无脑最短路n立方即可。。。。。
```
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
#define N 400+5
int map[N][N],n,m;
char str[N][N];
void check(int i,int j,int cnt)
{
if (str[i][j]==str[i][j+1]&&j+1<=m)
map[cnt][cnt+1]=map[cnt+1][cnt]=0;
else if(str[i][j]!=str[i][j+1]&&j+1<=m)
map[cnt][cnt+1]=map[cnt+1][cnt]=1;
if (str[i][j]==str[i][j-1]&&j-1>0)
map[cnt][cnt-1]=map[cnt-1][cnt]=0;
else if(str[i][j]!=str[i][j-1]&&j-1>0)
map[cnt][cnt-1]=map[cnt-1][cnt]=1;
if (str[i][j]==str[i-1][j]&&i-1> 0&&cnt-m>0)
map[cnt][cnt-m]=map[cnt-m][cnt]=0;
else if(str[i][j]!=str[i-1][j]&& i-1>0 && cnt-m>0)
map[cnt][cnt-m]=map[cnt-m][cnt]=1;
if (str[i][j]==str[i+1][j]&&i+1<=n)
map[cnt][cnt+m]=map[cnt+m][cnt]=0;
else if(str[i][j]!=str[i+1][j]&&i+1<=n)
map[cnt][cnt+m]=map[cnt+m][cnt]=1;
}
int main()
{
cin>>n>>m;
int cnt=0;
memset(map,0x3f,sizeof map);
for(int i=1;i<=n;++i)
scanf("%s",str[i]+1);

for(int i=1;i<=m;++i)
map[cnt][i]=0;
int end=n*m+1;
for(int i=(n-1)*(m)+1;i<=n*m;++i)
map[i][end]=0;
for(int i=1;i<=n;++i)
for(int j=1;j<=m;++j)
check(i,j,++cnt);
for(int k=0;k<=cnt+1;++k)
for(int i=0;i<=cnt+1;++i)
for(int j=0;j<=cnt+1;++j)
map[i][j]=min(map[i][j],map[i][k]+map[k][j]);
cout<<map[0][end]+1;
}

var
s:Array[0..100]of string;
n,m,i,j,k,l,o,p:longint;ans:int64;
f:array[0..21,0..21,0..21,0..21]of longint;
begin
ans:=maxlongint;
readln(n,m);
if n=1 then begin writeln(1);halt;end;
for i:=1 to n do readln(s[i]);
for i:=0 to n do for j:=0 to m do
for k:=0 to n do for l:=0 to m do f[i,j,k,l]:=1000000000;
for i:=1 to n do for j:=1 to m do
begin
if s[i-1,j]=s[i,j]then f[i,j,i-1,j]:=0 else f[i,j,i-1,j]:=1;
if s[i+1,j]=s[i,j]then f[i,j,i+1,j]:=0 else f[i,j,i+1,j]:=1;
if s[i,j-1]=s[i,j]then f[i,j,i,j-1]:=0 else f[i,j,i,j-1]:=1;
if s[i,j+1]=s[i,j]then f[i,j,i,j+1]:=0 else f[i,j,i,j+1]:=1;
end;
for k:=1 to n do for l:=1 to m do
for i:=1 to n do for j:=1 to m do
for o:=1 to n do for p:=1 to m do
if f[i,j,k,l]+f[k,l,o,p]<f[i,j,o,p] then f[i,j,o,p]:=f[i,j,k,l]+f[k,l,o,p];
for i:=1 to m do for j:=1 to m do
if f[1,i,n,j]<ans then ans:=f[1,i,n,j];
for i:=1 to m do for j:=1 to m do
if f[N,i,1,j]<ans then ans:=f[n,i,1,j];
writeln(ans+1);
end.
FLOYD水过

测试数据 #0: Accepted, time = 0 ms, mem = 464 KiB, score = 5
测试数据 #1: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #2: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #3: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #4: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #5: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #6: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #7: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #8: Accepted, time = 0 ms, mem = 464 KiB, score = 5
测试数据 #9: Accepted, time = 0 ms, mem = 464 KiB, score = 5
测试数据 #10: Accepted, time = 0 ms, mem = 464 KiB, score = 5
测试数据 #11: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #12: Accepted, time = 0 ms, mem = 456 KiB, score = 5
测试数据 #13: Accepted, time = 0 ms, mem = 464 KiB, score = 5
测试数据 #14: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #15: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #16: Accepted, time = 0 ms, mem = 464 KiB, score = 5
测试数据 #17: Accepted, time = 0 ms, mem = 464 KiB, score = 5
测试数据 #18: Accepted, time = 0 ms, mem = 460 KiB, score = 5
测试数据 #19: Accepted, time = 15 ms, mem = 464 KiB, score = 5

spfa，不解释
两个相邻的点连一条边，若是相同字母则边权为0,否则为1
然后初始节点不是1个，而是开头一行m个加入队列

代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#define N 21
#define M 21

struct edge{
int u,v,w;
};

struct point{
int val;
int num;
};

struct edge edge[N*M*4];
int u_index[N*M+1];
struct point point[N*M];
short in[N*M];
int stack[N*M],rear,front;
int n,m;
char map[N][M+1];

void push_on(int num,int val)
{
point[num].val = val;
if (!in[num]) {
in[num] = 1;
stack[rear++%(N*M)] = num;
}
}

void out_stack()
{
in[stack[front++%(N*M)]] = 0;
}

void add_edge(int u,int v,int w,int *r)
{
edge[*r].u = u;
edge[*r].v = v;
edge[*r].w = w;
*r = *r+1;
}

int cmp_edge(const void *a,const void *b)
{
static struct edge *c,*d;
c = (struct edge *)a; d = (struct edge *)b;
if (c->u == d->u)
return c->v-d->v;
else
return c->u-d->u;
}

void build_edge()
{
int i,j,k,u,rear,ii,jj;
int go[2][4] = {{0,0,1,-1},{1,-1,0,0}};
rear = 0;
for (i = 0;i < n;i++)
for (j = 0;j < m;j++) {
u = i*m+j;
for (k = 0;k < 4;k++) {
ii = i+go[0][k]; jj = j+go[1][k];
if ((ii < n) && (ii >= 0) && (jj < m) && (j >= 0))
if (map[i][j] == map[ii][jj])
add_edge(u,ii*m+jj,0,&rear);
else
add_edge(u,ii*m+jj,1,&rear);
}
}
qsort(edge,rear,sizeof(struct edge),cmp_edge);
/*set u_index*/
i = 0; u = 0;
while (u <= n*m) {
while (i < rear)
if (edge[i].u < u)
i++;
else
break;
u_index[u++] = i;
}
}

void base_point()
{
int i,j,tmp;
tmp = (1<<31)-1;
front = rear = 0;
memset(in,0,sizeof(in));
for (j = 0;j < m;j++)
push_on(j,1);
for (i = 1;i < n;i++)
for (j = 0;j < m;j++)
push_on(i*m+j,tmp);
}

void init()
{
int i;
scanf("%d%d",&n,&m);
for (i = 0;i < n;i++)
scanf("%s",map[i]);
build_edge();
base_point();
}

void spfa()
{
int u,i,t,v;
while (front < rear) {
u = stack[front%(N*M)];
for (i = u_index[u];i < u_index[u+1];i++) {
v = edge[i].v;
if (point[v].val > (t = point[u].val+edge[i].w))
push_on(v,t);
}
out_stack();
}
}

void print()
{
int j,t,ans;
for (ans = (1<<31)-1,t = n*m,j = 1;j <= m;j++)
if (ans > point[t-j].val)
ans = point[t-j].val;
printf("%d\n",ans);
}

int main()
{
init();
spfa();
print();
return 0;
}

const
b:array[1..2,1..4] of integer=((0,0,1,-1),(-1,1,0,0));
var
a:array[0..21,0..21] of char;
f:array[0..21,0..21] of longint;
x,y:array[0..10000]of longint;
n,m,h,t,i,j,nowx,nowy,xx,yy,ans:longint;
begin
readln(n,m);
for i:=1 to n do
begin
for j:=1 to m do
read(a[i,j]);
readln;
end;
fillchar(f,sizeof(f),$7f);
for i:=1 to m do
begin
x[i]:=1;
y[i]:=i;
f[1,i]:=1;
end;
h:=0;
t:=m;
while h<t do
begin
inc(h);
nowx:=x[h];nowy:=y[h];
for i:=1 to 4 do
begin
xx:=nowx+b[1,i];
yy:=nowy+b[2,i];
if (xx<1) or (xx>n) or (yy<1) or (yy>m) then continue;
if (a[xx,yy]=a[nowx,nowy]) and (f[xx,yy]>f[nowx,nowy]) then
begin
f[xx,yy]:=f[nowx,nowy];
inc(t);
x[t]:=xx;y[t]:=yy;
end;
if (a[xx,yy]<>a[nowx,nowy]) and (f[xx,yy]>f[nowx,nowy]+1) then
begin
f[xx,yy]:=f[nowx,nowy]+1;
inc(t);
x[t]:=xx;y[t]:=yy;
end;
end;
end;
ans:=maxlongint;
for i:=1 to m do
if f[n,i]<ans then ans:=f[n,i];
writeln(ans);
end.

表示此题一看就是宽搜。
听一中同学说DFS超时。。。
我关注了一下我的时限
测试数据 #0: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #1: Accepted, time = 0 ms, mem = 900 KiB, score = 5

测试数据 #2: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #3: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #4: Accepted, time = 0 ms, mem = 900 KiB, score = 5

测试数据 #5: Accepted, time = 3 ms, mem = 900 KiB, score = 5

测试数据 #6: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #7: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #8: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #9: Accepted, time = 0 ms, mem = 900 KiB, score = 5

测试数据 #10: Accepted, time = 0 ms, mem = 908 KiB, score = 5

测试数据 #11: Accepted, time = 0 ms, mem = 900 KiB, score = 5

测试数据 #12: Accepted, time = 0 ms, mem = 900 KiB, score = 5

测试数据 #13: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #14: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #15: Accepted, time = 0 ms, mem = 904 KiB, score = 5

测试数据 #16: Accepted, time = 15 ms, mem = 900 KiB, score = 5

测试数据 #17: Accepted, time = 0 ms, mem = 900 KiB, score = 5

测试数据 #18: Accepted, time = 15 ms, mem = 904 KiB, score = 5

测试数据 #19: Accepted, time = 0 ms, mem = 900 KiB, score = 5

宽搜霸气！

记忆化dfs, f表示走到(i,j)这个地方用神功的最少次数

这道题我WA了几次,纯属粗心~~

注意

1:样例中m表示行,n表示列

2:如果字母是连着的都可以可以直接用神功打掉

例如: A

AAAAA

A 一招全部打掉

3:答案的最坏情况为行数

所以当f>m时就可以直接跳出递归不做

要细心,此题比较经典

+++++++++++++++++++++++++++++++++++++++++++++++++++++++

弱弱的程序:

const fx:array[1..4,1..2] of integer=((1,0),(0,1),(-1,0),(0,-1));

var

map:array[0..500,0..500] of char;

u:array[0..500,0..500] of boolean;

f:array[0..500,0..500] of longint;

n,m:longint;

i,j,k,l,ans:longint;

procedure int;

begin

readln(n,m);

for i:=1 to n do

begin

for j:=1 to m do read(map);

readln;

end;

end;

procedure dfs(x,y:longint);

var

i,j,xx,yy:longint;

begin

if x=n then

begin

if f[x,y]=ans then exit;

for i:=1 to 4 do

begin

xx:=x+fx;

yy:=y+fx;

if (xxn) or (yym) then continue;

if u[xx,yy] then

begin

u[xx,yy]:=false;

if ((map[xx,yy]=map[x,y]) and (f[x,y]

Floyed:

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

├ 测试数据 11：答案正确... 0ms

├ 测试数据 12：答案正确... 0ms

├ 测试数据 13：答案正确... 0ms

├ 测试数据 14：答案正确... 0ms

├ 测试数据 15：答案正确... 0ms

├ 测试数据 16：答案正确... 0ms

├ 测试数据 17：运行超时...

├ 测试数据 18：运行超时...

├ 测试数据 19：答案正确... 0ms

├ 测试数据 20：运行超时...

---|---|---|---|---|---|---|---|-

Unaccepted 有效得分：85 有效耗时：0ms

Dijkstra:

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

├ 测试数据 11：答案正确... 0ms

├ 测试数据 12：答案正确... 0ms

├ 测试数据 13：答案正确... 0ms

├ 测试数据 14：答案正确... 0ms

├ 测试数据 15：答案正确... 0ms

├ 测试数据 16：答案正确... 0ms

├ 测试数据 17：答案正确... 0ms

├ 测试数据 18：答案正确... 0ms

├ 测试数据 19：答案正确... 0ms

├ 测试数据 20：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms