Algorithm 字符串形式的列表中的字符

早上好

我很惭愧于发布这个问题，因为我应该能够独自解决这个问题，但目前我想不出任何更好的解决方案

假设我有一个字符列表和一个字符串。我想知道

S

中的每个字符是否都属于

L

，目前我想不出的唯一解决方案是琐碎的问题

boolean Result = true
boolean Temp = false

for i from 1 to S.Length
    Temp <- false
    for j from 1 to A.Count
        if (S[i] == A[j]) Temp <- true

    Result = Result && Temp

return Result

boolean结果=true
布尔温度=假
对于长度为1到S的i
Temp您可以按字母顺序对
L
和
S
进行排序，例如使用快速排序。
现在，您可以逐个字符比较
L
和
S
，因此您的时间将是
O（n1 log n1）（对于L的排序）+O（n2 log n2）（对于S的排序）+Max（n1，n2）（用于按字符比较两个排序的字符串）
其中
n1=L.Length
和
n2=S.Length
，因此给定
n=Max（n1，n2）
，你应该有一个时间
O（n logn）
（我希望）：-）

具体实现取决于您希望如何处理多个相等的字母。如果
L=“A”
和
S=“AA”
，那么
S
是否与
L
匹配？
您可以只计算S和L中的字符，然后比较计数吗？这避免了嵌套循环结构，因此我认为这是O（N+M）而不是O（MN）（其中M和N是字符串的长度）

int[]Lcount=newint[256]；
int[]scont=新int[256]；
对于（int i=0；i，这里迭代字符列表的代价是O（A.Count）。您可以将字符存储在A中，这样您就可以确定S[i]是否属于A，只要适当选择了哈希函数

因此，使用一个好的哈希函数，可以将全局开销从O（S.Length*a.Count）减少到O（S.Length）

如果您处理的是ASCII字符，那么您的哈希表可能会简化为128个元素的数组，标识为“哈希函数”。如果您处理的是Unicode字符，但您的文本包含大多数ASCII字符，那么您可能会想到这种情况的一种变体。
即使考虑Unicode，也只有1114112个字符（0…0x10FFFF）（请参阅），因此它是1114112位…因此是140kb。我认为这是合理的。
int[] Lcount = new int[256];
int[] Scount = new int[256];

for (int i=0;i<L.length;++i) {
  Lcount[L.charAt(i)]++;
}

for (int i=0;i<S.length;++i) {
  Scount[S.charAt(i)]++;
}

for (int i=0;i<256;i++) {
   // S doesn't have the characters in L so can't be a subset
   if (Scount[i] < Lcount[i]) {
      return false;
   }
}

return true;