Kattis 挑战：电话清单，超过 4 秒的时间限制，C#

Question

使用在线自动化测试系统 Kattis，我面临的挑战（在 C# 中）创建一个电话号码列表，然后找出其中任何一个是前缀还是另一个。

（参见：https://ncpc.idi.ntnu.no/ncpc2007/ncpc2007problems.pdf，任务 A）

提供答案相对容易，但无论我如何尝试，我都无法逃脱得到结果：超出时间限制，还有一些进一步的信息表明运行程序需要超过 4 秒（通过自动程序）。

我曾多次尝试从头开始重写它，并且我已经尝试了我可以在互联网上找到的所有现有建议。我发现自己完全不知所措，主要是因为最终我无法确定到底出了什么问题。

This code 是在类似（但未解决）thread 上提出的，但并没有发挥作用 - 但这是迄今为止我见过的最好的：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PhoneList
{
class Program
{
    static void Main(string[] args)
    {
        // Save number of test cases.
        var numTestCases = int.Parse(Console.ReadLine());

        // Do this for each test case.
        for (int i = 0; i < numTestCases; i++)
        {
            // Save number of phone numbers.
            var numPhoneNumbers = int.Parse(Console.ReadLine());

            // Save all phonenumbers in the list.
            var phoneNumbersList = new List<string>();
            for (int j = 0; j < numPhoneNumbers; j++)
            {
                string number = Console.ReadLine().Trim();

                // Add to list.
                phoneNumbersList.Add(number);
            }

            // Write output.
            if (phoneNumbersList.All(n => !phoneNumbersList.Except(new[] { n }).Any(o => o.StartsWith(n))))
            {
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");
            }
        }
    }
}
}

有什么建议吗？

Answer 1

您是否尝试在添加所有号码后对电话号码列表进行排序（按字母顺序），然​​后检查第 n+1 项是否以第 n 项开头？

phoneNumbersList.Sort((x,y) => string.Compare(x, y));

var consistent = true;
for (var j = 0; j < phoneNumbersList.Count - 1; ++j)
{
   if (phoneNumbersList[j + 1].StartsWith(phoneNumbersList[j]))
   {
        consistent = false;
        break;
   }
}

Console.WriteLine(consistent ? "YES" : "NO");

Answer 2

并非总是最短和最好的就是最好的 :-) 尝试以下方法：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Samples
{
    class PhoneListProcessor
    {
        const int MaxCount = 10000;
        const int MaxDigits = 10;
        Dictionary<int, bool> phoneNumberInfo = new Dictionary<int, bool>(MaxCount * MaxDigits);
        public bool Process(IEnumerable<string> phoneNumbers, bool readToEnd)
        {
            phoneNumberInfo.Clear();
            using (var e = phoneNumbers.GetEnumerator())
            {
                while (e.MoveNext())
                {
                    if (Process(e.Current)) continue;
                    if (readToEnd)
                    {
                        while (e.MoveNext()) { }
                    }
                    return false;
                }
            }
            return true;
        }
        bool Process(string phoneNumber)
        {
            var phoneNumberInfo = this.phoneNumberInfo;
            int phoneCode = 0;
            int digitPos = 0;
            bool hasSuffix = true;
            while (true)
            {
                phoneCode = 11 * phoneCode + (phoneNumber[digitPos] - '0' + 1);
                bool isLastDigit = ++digitPos >= phoneNumber.Length;
                bool isPhoneNumber;
                if (hasSuffix && phoneNumberInfo.TryGetValue(phoneCode, out isPhoneNumber))
                {
                    if (isPhoneNumber || isLastDigit) return false;
                }
                else
                {
                    phoneNumberInfo.Add(phoneCode, isLastDigit);
                    if (isLastDigit) return true;
                    hasSuffix = false;
                }
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var processor = new PhoneListProcessor();
            int testCount = int.Parse(Console.ReadLine());
            for (int testIndex = 0; testIndex < testCount; testIndex++)
            {
                int count = int.Parse(Console.ReadLine());
                var numbers = Enumerable.Range(0, count).Select(_ => Console.ReadLine());
                bool readToEnd = testIndex + 1 < testCount;
                bool valid = processor.Process(numbers, readToEnd);
                Console.WriteLine(valid ? "YES" : "NO");
            }
        }
    }
}

基本上，它所做的是动态构建并在任务限制和细节下使用dictionary prefix trie 的变体。每个电话号码或前缀都被编码为以 11 为基数且不带零的整数（每个数字都递增，因此我们有 1-10 而不是 0-9），以便区分带前导零的数字和不带前导零的相同数字请求。

Answer 3

我有两个建议：

1. 不要使用phoneNumbers.Sort(); 按字母顺序排序，而是尝试按长度排序：numbers.Sort((a, b) => a.Length - b.Length);。直觉是，由于较长的字符串不可能成为较短字符串的前缀，因此我们可以跳过检查这些并节省一些工作（一旦发现不一致就尽早救助很重要）。
2. 由于电话长度只有 10 位，因此可以对其进行迭代并将每个前缀存储在 HashSet 中。 HashSet 为我们提供了对所有先前计算的前缀的 O(1) 查找时间，因此每个测试用例的时间复杂度为 O(n) 用于检查，O(n log(n)) 用于预先排序成本。

代码如下：

using System;
using System.Collections.Generic;

namespace PhoneList
{
    class Program
    {
        static bool IsConsistent(List<string> numbers)
        {
            numbers.Sort((a, b) => a.Length - b.Length);
            var prefixes = new HashSet<string>();

            foreach (var n in numbers)
            {
                for (int i = 1; i < n.Length; i++)
                {
                    if (prefixes.Contains(n.Substring(0, i)))
                    {
                        return false;
                    }
                }

                prefixes.Add(n);
            }

            return true;
        }

        static void Main(string[] args)
        {
            int testCases = Int32.Parse(Console.ReadLine());

            for (int i = 0; i < testCases; i++)
            {
                int phoneNumbersCount = Int32.Parse(Console.ReadLine());
                var numbers = new List<string>();

                for (int j = 0; j < phoneNumbersCount; j++)
                {
                    numbers.Add(Console.ReadLine());
                }

                Console.WriteLine(IsConsistent(numbers) ? "YES" : "NO");
            }
        }
    }
}