如何修改代码使有序子序列"1,4"匹配G[1]与G[3]？

嘿，我来帮你搞定这个需求！先理清楚当前的情况：

给定的字符串列表 G 是这样的：

[0] : {"1,2,5"} 
[1] : {"1,2,4,5,6"} 
[2] : {"2,4,6"} 
[3] : {"1,4,6"} 

原来的代码用 if (G[i].Contains("1,4")) 能精准判断 "1,4" 作为完整子串存在于 G[3] 里，但现在需要升级：既要保留这个精准匹配的功能，还要能识别出搜索项作为有序子序列存在的情况（比如 "1,4" 是 G[1] 的有序子序列，得被检测到），而且搜索项的顺序必须严格对应，不能乱。

你提供的原有代码片段已经在处理有序子序列的匹配了，但没把原有的精准匹配逻辑加进去，接下来我给你两种修改方案，按需选用：

方案一：先精准匹配，再子序列匹配（效率优先） #

这种方案会先检查是否是精准匹配，如果是就直接执行业务逻辑，跳过后续的子序列遍历，节省性能：

for (int i = 0; i < candid.Count; i++) { 
    foreach (TransactionTP b in transactions) { 
        string search = candid[i]; 
        var searchNumbers = search.Split(',').Select(int.Parse).ToList(); 
        for (int j = 0; j < G.Count; j++) { 
            // 先保留原有精准匹配逻辑
            if (G[j].Contains(search)) {
                arraye[i] += b.transactionUtility;
                continue; // 命中精准匹配，直接处理下一个G元素
            }

            // 原有有序子序列匹配逻辑保留
            IEnumerable<int> numbers = G[j].Split(',').Select(int.Parse); 
            int idx = 0; 
            foreach (var number in numbers) { 
                if (number == searchNumbers[idx]) { 
                    idx++; 
                } 
                if (idx == searchNumbers.Count) { 
                    arraye[i] += b.transactionUtility; 
                    break; 
                } 
            } 
        } 
    } 
}

方案二：统一判断逻辑（可读性优先） #

如果觉得分开判断不够直观，也可以把两种匹配逻辑整合到一个布尔变量里，代码结构更清晰：

for (int i = 0; i < candid.Count; i++) { 
    foreach (TransactionTP b in transactions) { 
        string search = candid[i]; 
        var searchNumbers = search.Split(',').Select(int.Parse).ToList(); 
        for (int j = 0; j < G.Count; j++) { 
            bool isMatch = false;

            // 检查精准匹配
            if (G[j].Contains(search)) {
                isMatch = true;
            } else {
                // 检查有序子序列
                IEnumerable<int> numbers = G[j].Split(',').Select(int.Parse); 
                int idx = 0; 
                foreach (var number in numbers) { 
                    if (number == searchNumbers[idx]) { 
                        idx++; 
                    } 
                    if (idx == searchNumbers.Count) { 
                        isMatch = true;
                        break; 
                    } 
                }
            }

            // 只要满足任意一种匹配，就执行累加
            if (isMatch) {
                arraye[i] += b.transactionUtility;
            }
        } 
    } 
}

小说明 #

• 两种方案都完美保留了原有的精准匹配功能，同时新增了有序子序列的检测。
• 有序子序列的判断逻辑是严格按照顺序来的，比如搜索 "4,1" 的话，就不会匹配到 G[1] 或者 G[3]，完全符合你的要求。

内容的提问来源于stack exchange，提问作者Reza Hatami