找到广场上的所有水坑 - Java村庄水井算法优化-CSDN博客

这看起来效果很好 . 这个想法是它是一个递归函数，它检查是否存在允许它逃逸到边缘的“向外流” . 如果没有这种逃脱的值将会淹没 . 我在你的两个输入文件上测试了它，它运行得很好 . 我为你复制了这两个文件的输出 . 原谅我讨厌使用全局变量而不是，我认为算法背后的概念很重要，不是很好的风格:)

#include

using namespace std;

int SIZE_X;

int SIZE_Y;

bool **result;

int **INPUT;

bool flowToEdge(int x, int y, int value, bool* visited) {

if(x < 0 || x == SIZE_X || y < 0 || y == SIZE_Y) return true;

if(visited[(x * SIZE_X) + y]) return false;

if(value < INPUT[x][y]) return false;

visited[(x * SIZE_X) + y] = true;

bool left = false;

bool right = false;

bool up = false;

bool down = false;

left = flowToEdge(x-1, y, value, visited);

right = flowToEdge(x+1, y, value, visited);

up = flowToEdge(x, y+1, value, visited);

down = flowToEdge(x, y-1, value, visited);

return (left || up || down || right);

}

int main() {

ifstream myReadFile;

myReadFile.open("test.txt");

myReadFile >> SIZE_X;

myReadFile >> SIZE_Y;

INPUT = new int*[SIZE_X];

result = new bool*[SIZE_X];

for(int i = 0; i < SIZE_X; i++) {

INPUT[i] = new int[SIZE_Y];

result[i] = new bool[SIZE_Y];

for(int j = 0; j < SIZE_Y; j++) {

int someInt;

myReadFile >> someInt;

INPUT[i][j] = someInt;

result[i][j] = false;

}

for(int i = 0; i < SIZE_X; i++) {

for(int j = 0; j < SIZE_Y; j++) {

bool visited[SIZE_X][SIZE_Y];

for(int k = 0; k < SIZE_X; k++)//You can avoid this looping by using maps with pairs of coordinates instead

for(int l = 0; l < SIZE_Y; l++)

visited[k][l] = 0;

result[i][j] = flowToEdge(i,j, INPUT[i][j], &visited[0][0]);

}

for(int i = 0; i < SIZE_X; i++) {

cout << endl;

for(int j = 0; j < SIZE_Y; j++)

cout << result[i][j];

}

cout << endl;

}

16乘16档：

1111111111111111

1101111100010111

1111111011101011

1111000110101011

1011001011101111

1110011111011111

1100000101101011

1010100010110011

1110111111101111

1101101011011101

1010111111101111

1110011010110011

1010111111111011

1111110110100111

1011111111111111

1111111111111111

8乘8档

11111111

11011111

11110111

11111111

11000011

11111111

您可以通过执行多项操作轻松且显着地优化此算法 . 答：找到路线后立即返回真会会大大加快速度 . 您还可以将其全局连接到当前结果集，以便任何给定点只需要找到已知流点的流点，而不是一直到边缘 .

所涉及的工作，每个n都必须检查每个节点 . 但是，通过优化，对于大多数情况，我们应该能够比n ^ 2低得多，但在最坏的情况下它仍然是n ^ 3算法......但是创建这个算法将非常困难(使用适当的优化逻辑) . ..动态编程获胜！)

编辑：

修改后的代码适用于以下情况：

8 8

1 1 1 1 1 1 1 1

1 0 0 0 0 0 0 1

1 0 1 1 1 1 0 1

1 0 1 0 0 1 0 1

1 0 1 1 0 1 0 1

1 0 0 0 0 1 0 1

1 1 1 1 1 1 1 1

这些是结果：

11111111

10000001

10111101

10100101

10110101

10000101

11111111

现在，当我们删除底部的1时，我们希望看到没有搅拌 .

8 8

1 1 1 1 1 1 1 1

1 0 0 0 0 0 0 1

1 0 1 1 1 1 0 1

1 0 1 0 0 1 0 1

1 0 1 1 0 1 0 1

1 0 0 0 0 1 0 1

1 1 1 1 1 1 0 1

这些都是结果

1 1 1 1 1 1 1 1

java村庄水井,找到广场上的所有水坑（算法）