Question

我想生成从（0,0）到（2n，0）的schröder路径没有峰值，即没有向上步骤，紧接着是向下步骤。一些例子是n = 3：shröder paths。

/编码为U， - 编码为R，\编码为D.以下是生成这些路径的代码：

 public static void addParen(List<String> list, int upstock,int rightstock,int     
      downstock,bool B, char[] str, int count,int total,int n)
    {


        if (total == n && downstock == 0)
        { 
            String s = copyvalueof(str);
            list.Add(s);
        }

        if (total > n || (total==n && downstock>0) )
            return;
        else
        {
            if (upstock > 0 && total<n)
            { 
                str[count] = 'U';
                addParen(list, upstock - 1,rightstock, downstock+1,B=true,   str, count + 1,total+1,n);
            }
            if (downstock > 0 && total<n && B==false)
            {
                str[count] = 'D';
                addParen(list, upstock,rightstock, downstock - 1,B=false, str, count + 1,total+1,n);
            }

            if (rightstock > 0 && total < n)
            {
                str[count] = 'R';
                addParen(list, upstock, rightstock-1, downstock, B = false, str, count + 1, total + 2,n);
            }
        }
    }

    public static List<String> generatePaths(int count)
    {

        char[] str = new char[count * 2];
        bool B = false;
        List<String> list = new List<String>();
        addParen(list, count-1, count, 0,B,str, 0, 0,count*2);
        return list;
    }

总数是2n。我从n-1 ups n权利和零开始开始。因为没有Up我的bool B是假的（如果有一个up然后down就不能在它之后，所以为了防止这个我把B = true来阻止它。）如果上升，那么应该有相应的下降，总数应该增加1。如果当时正确，那么总计应该增加2.我的算法一般都是这样的，但我无法通过这种实现获得正确的结果。

Answer 1

最初的解决方案并不适应OP的需求，因为移植到javascript太复杂了，目的是为了展示更好的解决这些问题的实践，而不是特别轻松解决这个问题。

但是本着使用不可变类型来解决路径算法的精神，我们仍然可以用更简单的方式这样做：我们将使用string。

一如既往，让我们建立我们的基础设施：让我们的生活更轻松的工具：

private const char Up = 'U';
private const char Down = 'D';
private const char Horizontal = 'R';
private static readonly char[] upOrHorizontal = new[] { Up, Horizontal };
private static readonly char[] downOrHorizontal = new[] { Down, Horizontal };
private static readonly char[] all = new[] { Up, Horizontal, Down };

一个方便的小助手方法：

private static IList<char> GetAllPossibleDirectionsFrom(string path)
{
    if (path.Length == 0)
        return upOrHorizontal;

    switch (path.Last())
    {
        case Up: return upOrHorizontal;
        case Down: return downOrHorizontal;
        case Horizontal: return all;
        default:
            Debug.Assert(false);
            throw new NotSupportedException();
    }
}

请记住，将问题分解为较小的问题。所有难题都可以解决，解决更小的问题。这种辅助方法很难出错;这很好，很难在简单的简短方法中写出错误。

现在，我们解决了更大的问题。我们不会使用迭代器块，因此移植更容易。我们将在这里使用可变列表来跟踪我们找到的所有有效路径。

我们的递归解决方案如下：

private static void getPaths(IList<string> allPaths, 
                             string currentPath, 
                             int height,
                             int maxLength,
                             int maxHeight)
{
    if (currentPath.Length == maxLength)
    {
        if (height == 0)
        {
            allPaths.Add(currentPath);
        }
    }
    else
    {
        foreach (var d in GetAllPossibleDirectionsFrom(currentPath))
        {
            int newHeight;

            switch (d)
            {
                case Up:
                    newHeight = height + 1;
                    break;
                case Down:
                    newHeight = height - 1;
                    break;
                case Horizontal:
                    newHeight = height;
                    break;
                default:
                    Debug.Assert(false);
                    throw new NotSupportedException();
            }

            if (newHeight < 0 /*illegal path*/ ||
                newHeight > 
                    maxLength - (currentPath.Length + 1)) /*can not possibly
                                                            end with zero height*/
                    continue;

            getPaths(allPaths, 
                     currentPath + d.ToString(), 
                     newHeight, 
                     maxLength, 
                     maxHeight);
        }
    }
}

不多说，它非常自我解释。我们可以减少一些论点; height并非绝对必要，我们可以在当前路径中计算 ups 和 down 并计算出我们当前所处的高度，但这似乎很浪费。 maxLength也可以，也可能应该被移除，我们有足够的信息maxHeight。

现在我们只需要一种方法来解决这个问题：

public static IList<string> GetSchroderPathsWithoutPeaks(int n)
{
    var allPaths = new List<string>();
    getPaths(allPaths, "", 0, 2 * n, n);
    return allPaths;
}

我们定了！如果我们将其用于试驾：

var paths = GetSchroderPathsWithoutPeaks(2);
Console.WriteLine(string.Join(Environment.NewLine, paths));

我们得到了预期的结果：

URRD
URDR
RURD
RRRR

至于为什么你的解决方案不起作用？好吧，只是你无法弄明白的事实说明了当前解决方案开始看起来多么复杂。当发生这种情况时，通常最好退一步，重新考虑你的方法，写下你的程序应该逐步完成并重新开始的明确规范。

生成Schröder路径

1 个答案: