优化此C#算法

这是一个算法问题，我有解决方案，但它有性能问题

问题描述

---

有n个变量和m个需求。需求表示为（x，这里有一个Java解决方案，即使在n=13，m=199的情况下，它对我来说也非常快：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

public class Assignments
{
    private static Map <String, Long> solutions = new HashMap <String, Long> ();

    private static boolean [][] constraints;

    private static long solve (int n, int [] low, int [] high)
    {
        StringBuilder sb = new StringBuilder ();

        for (int i = 0; i < n; i++)
        {
            sb.append (low [i]);
            sb.append (high [i]);
        }

        String signature = sb.toString ();

        Long result = solutions.get (signature);
        if (result == null)
        {
            result = Long.valueOf (doSolve (n, low, high));
            solutions.put (signature, result);
        }

        return result.longValue ();
    }

    private static long doSolve (int n, int [] low, int [] high)
    {
        if (n == 0) return 1;
        else
        {
            long result = 0;

            for (int i = low [n - 1]; i <= high [n - 1]; i++)
            {
                int [] l = new int [n - 1];
                int [] h = new int [n - 1];

                for (int j = 0; j < n - 1; j++)
                {
                    l [j] = constraints [n - 1][j] ? Math.max (low [j], i) : low [j];
                    h [j] = constraints [j][n - 1] ? Math.min (high [j], i) : high [j];
                }

                result += solve (n - 1, l, h);
            }

            return result;
        }
    }

    public static void main(String[] args) throws Exception
    {
        BufferedReader reader = 
            new BufferedReader (
                new InputStreamReader(System.in));

        String nm = reader.readLine ();
        String [] pair = nm.split(" ");
        int n = Integer.parseInt(pair [0]);
        int m = Integer.parseInt(pair [1]);

        constraints = new boolean [n][];
        for (int i = 0; i < n; i++)
            constraints [i] = new boolean [n];

        int [] low = new int [n];
        int [] high = new int [n];
        for (int i = 0; i < n; i++)
            high [i] = 9;

        for (int i = 0; i < m; i++)
        {
            String ab = reader.readLine();
            pair = ab.split (" ");
            int a = Integer.parseInt(pair [0]);
            int b = Integer.parseInt(pair [1]);
            constraints [a][b] = true;
        }

        System.out.println(solve (n, low, high));
    }
}

输出：

5500000000000

497420

另一个示例输入：

13 1
3 8

13 12
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
10 11
11 12

输出：

5500000000000

497420

---

也许可以做一些日志记录，看看是否有任何不必要的执行。添加计时块，看看什么地方需要很长时间才能执行。在任何情况下，即使for循环只是一个单行，也要放上那些该死的花括号。@JanDvorak不一定。我是支持花括号的人。但有些人觉得代码看起来更有用当单行程序省略大括号时，简洁，不太杂乱。如果完全没有用，语言设计者不会给出这个选项。表达自己的观点和信仰是可以的，但当向学生提供关于不明确问题的建议时，必须谨慎。至少，这种语言的优点是e这两种方法都必须让人知道。另外，最好避免粗鲁无礼（re:“该死的花括号”）。@JanDvorak我的意思是c#的力量在循环中缺失。类似的东西可以用来创建列表，而不是使用for循环进行迭代。list x=可枚举。Repeat（value，count）。ToList（）；@IsaacCambron这是来自hackerrank.com的一个问题。这里最难的测试是：13 1而不是13 199。对于这个任务，计算所有排列是不正确的解决方案，因为结果可能有值n！我的算法几乎立即返回n=13，m=1的

5500000000000

。@MikhailVladimirov谢谢你的回答。有两个好的点从中我学到了：1）将约束存储在布尔数组中；2） 存储部分答案并重复使用，以避免第二次计算。注：最后一行代码是硬编码13，应该是n，正确的答案应该被1007模化。@rockXrock抓得好。修正了。@MikhailVladimirov如果你也对你的算法做一些解释的话，那就太好了