Question

我正在尝试编写代码，以检查是否可以按照某个规则到达数组的末尾。从一个整数数组的第一个元素开始，存储在该位置的数字是你可以前进或后退的跳数。目标是到达Vector的末尾，由0值表示。

 bool Solvable(int start, Vector<int> & squares) {
        int steps = squares[start];
        int prev = start - steps;
        int forward = start + steps;
        if (prev >= 0) {
            if (squares[prev] != squares[start]) {
                return Solvable(prev, squares);
            }
        }
        if (forward < squares.size()) {
            if (squares[forward] == 0) return true;
            if (squares[forward] != squares[start]) {
                return Solvable(forward, squares);
            }
        }
        return false;
    }

代码似乎不起作用，因为我认为我错过了一个基本案例，但我似乎无法弄清楚我需要的其他基本案例。

谢谢！

Answer 1

有几个问题。首先，你的代码只会选择向前或向后，你永远不会同时选择。原因是你总是说return Solvable。你需要的是这样的东西

// try backwards
bool found = Solvable(prev, squares);
// did it work?
if (found)
  return true;
// oh well try forwards
return Solvable(forward, squares);

没有检查基本情况，也没有在这里检查越界，但希望你能得到这个想法。

第二个问题是您的squares[forward] != squares[start]和squares[prev] != squares[start]测试。他们似乎并不像我所描述的那样成为问题的一部分。我会放弃它们。

说明递归BTW的好问题。

Answer 2

这是一个检测周期并跟踪您是否尝试从特定方块向前或向后移动的版本。使用具有非递归前端的递归辅助函数来设置变量（此处为fwd和bck向量）以跟踪您正在执行的操作的模式非常常见。

#include <iostream>
#include <vector>

using namespace std;

bool helper(int cur, const vector<int> &squares,
            vector<bool> &fwd, vector<bool> &bck)
{
  cout << "cur=" << cur << "  sq=" << squares[cur] << endl;
  if (squares[cur] == 0) return true;     // Found.
  if (fwd[cur] && bck[cur]) return false; // Cycle.
  if (!fwd[cur]) {                        // Try forwards.
    fwd[cur] = true;
    int up = cur + squares[cur];
    if (up < squares.size()) {
      cout << "Forwards" << endl;
      bool found = helper(up, squares, fwd, bck);
      if (found) return true;
    }
  }
  if (!bck[cur]) {                        // Try backwards.
    bck[cur] = true;
    int dn = cur - squares[cur];
    if (dn >= 0) {
      cout << "Backwards" << endl;
      bool found = helper(dn, squares, fwd, bck);
      if (found) return true;
    }
  }
  return false;
}

bool solvable(const vector<int> &squares)
{
  vector<bool> fwd(squares.size(), false);
  vector<bool> bck(squares.size(), false);
  return helper(0, squares, fwd, bck);
}

int sqs[] = { 2, 3, 1, 1, 4, 3, 4, 0, 1, 3, 1 };

int main(void)
{
  vector<int> sq(sqs, sqs + sizeof(sqs) / sizeof(int));
  cout << solvable(sq) << endl;
}

递归问题有助于C ++

2 个答案: