Question

如何以更好的方式重写以下代码以提供最佳性能

private static void GetCount(int No, int[,] Positions)
        {
            List<int> lstRows = new List<int>();
            List<int> lstCols = new List<int>();
            int count = 0;       

            //Get the unique rows and columns
            for (int i = 0; i < Positions.Length / 2; i++)
            {
                if (!lstRows.Contains(Positions[i, 0])) lstRows.Add(Positions[i, 0]);
                if (!lstCols.Contains(Positions[i, 1])) lstCols.Add(Positions[i, 1]);
            }
            //get row count
            for (int i = 0; i < lstRows.Count; i++) count += 8;
            //get column count
            for (int i = 0; i < lstCols.Count; i++) count += 8;

            int output = No-count;

            Console.WriteLine(output);
        }

调用GetCount(1, new int[,] { { 6, 3 } });

Answer 1

for (int i = 0; i < lstRows.Count; i++) count += 8;
for (int i = 0; i < lstCols.Count; i++) count += 8;

你正在成倍增长，所以只需使用

count += 8 * (lstRows.Count + lstCols.Count);

这会降低计算的复杂度，从O（N）到O（1）

Answer 2

这个怎么样：

private static void GetBuildingCount1(int No, int[,] Positions)
{
    var lstRows = new HashSet<int>();
    var lstCols = new HashSet<int>();           

    //Get the unique rows and columns
    for (int i = 0; i < Positions.Length / 2; i++)
    {
        lstRows.Add(Positions[i, 0]);
        lstCols.Add(Positions[i, 1]);
    }

    var count = (lstRows.Count + lstCols.Count) * 8;

    var output = No-count;

    Console.WriteLine(output);
}

如果您不想使用循环并希望使用纯lambda和linq（仅用于更少的代码，而不是性能）：

private static void GetBuildingCount1(int No, int[,] Positions)
{
    var rows = Positions.Cast<int>().Where((p, i) => i % 2 == 0).Distinct().Count();
    var cols = Positions.Cast<int>().Where((p, i) => i % 2 == 1).Distinct().Count();
    var result = No - (rows + cols) * 8;
    Console.WriteLine(result);
}

Answer 3

同时替换

List<int> lstRows = new List<int>();
List<int> lstCols = new List<int>();

与

HashSet<int> lstRows = new HashSet<int>();
HashSet<int> lsTCols = new HashSet<int>();

不改变任何其他内容。包含检查将是O（1）而不是O（n）。

在最佳优化的代码中重写以下代码

3 个答案: