Question

I am preparing myself for programming competitions and i would like to know how can i solve this problem. I guess it’s geometry problem, and it seems i can’t get any ideas about solving it.

Here it is:

There is a yard in which there are wolves and sheep. In the yard there are also blocks which do not allow to pass. The wolves are represented with ‘w’ and the sheep with ‘s’, while the blocks are with ‘#’ and the space where everyone can move is ‘.’ . So a possible input will look like:

8 8
.######.
#..s...#
#.####.#
#.#w.#.#
#.#.s#s#
#s.##..#
#.w..w.#
.######.

The 2 numbers above the yard are rows x columns.

As you can see, by this there can be formed sectors of different kind in the yard. Here are two sectors:

####
#.w#
####
#s.#

In the first one there is a wolf and in the second a sheep. Because they are placed in two different sectors (i.e. the wolf can’t get to the sheep), he can’t eat it. If they were in a same sector, the wolf would eat the sheep.

My question for you is this: Given an input like the ones above, how should i calculate how many sheep will survive ? How can i represent the ‘yard’ in c++ ? How should the algorithm looks like ? Are there any materials for understanding similar problems and issues ?

Any help is appreciated. Thank you in advance.

Answer 1

What you are looking for here is to find the connected components of the graph, then you just need to count the number of wolves and sheep in each one.

using namespace std;

int w, h;
cin >> w >> h;
vector<string> grid(h);
for (int i = 0; i < h; ++i)
  cin >> grid[i];

vector< vector<bool> > seen(h, vector<bool>(w, false));
int survived = 0;
const int mx[] = {-1, 0, 1, 0}, my[] = {0, -1, 0, 1};

for (int i = 0; i < h; ++i)
  for (int j = 0; j < w; ++j)
    if (!seen[i][j] && grid[i][j] != '#')
    {
      int sheep = 0, wolves = 0;
      typedef pair<int, int> point;
      stack<point> s;
      s.push(point(i, j));

      while (!s.empty())
      {
        point p = s.top();
        int x = p.first, y = p.second;
        if (grid[x][y] == 'w') wolves++;
        if (grid[x][y] == 's') sheep++;
        for (int k = 0; k < 4; ++k)
        {
          int x2 = x + mx[k], y2 = y + my[k];
          if (x2<0 || x2>=h || y2<0 || y2>=w) continue;
          if (grid[x2][y2] == '#' || seen[x2][y2]) continue;
          s.push(point(x2, y2));
        }
      }
      survived += max(0, sheep - wolves);
    }

cout << "Surviving sheep = " << survived << endl;

Running time and memory usage is optimal at O(rows x columns).

Note that code is untested, but I believe this should work.