C＃中的关联矩阵是否有更有效的方法？

Question

I implemented an algorithm using dictionaries with tuple keys, and the algorithm works, but it is very very slow. I have a set of strings. I was trying to implement an associative matrix where A["abc","bcde"] = 2, the amount of overlap of the two strings. The tuples in L are keys in A. L is a sorted array => A[L[i]] < A[L[i+1]] I merge the two strings with the biggest overlap in the set, then I update the "matrix" and the L list. I do it in a loop until the set has only 1 element. My problem is that with dictionary the algorithm is too slow. Is there a more efficient way to do this? Here is my code:

List<string> words = new List<string>(wordsFromFile);

Dictionary<Tuple<string, string>, int> A = new Dictionary<Tuple<string, string>, int>();
List<Tuple<string, string>> L = new List<Tuple<string,string>>();

(I used counting sort for making L. After that refreshing the matrix and the list is very time consuming:)

            while (words.Count > 1)
            {
                string LastItem1 = L.Last().Item1;
                string LastItem2 = L.Last().Item2;
                words.Remove(LastItem1);
                words.Remove(LastItem2);
                string newElement = merge(LastItem1, LastItem2);
                words.Add(newElement);
                for (int i = 0; i < words.Count; ++i)
                {
                    if (words[i] == newElement)
                    {
                        Tuple<string, string> tmp = new Tuple<string, string>(newElement, newElement);
                        A[tmp] = 0;
                    }
                    else
                    {
                        Tuple<string, string> tmp = new Tuple<string, string>(newElement, words[i]);
                        A[tmp] = A[new Tuple<string, string>(LastItem2, words[i])];
                        tmp = new Tuple<string, string>(words[i], newElement);
                        A[tmp] = A[new Tuple<string, string>(words[i], LastItem1)];
                    }
                }
                var itemsToRemove = A.Where(f => f.Key.Item1 == LastItem1 || f.Key.Item1 == LastItem2 || f.Key.Item2 == LastItem1 || f.Key.Item2 == LastItem2).ToArray();
                foreach (var item in itemsToRemove)
                    A.Remove(item.Key);

                L.Remove(L.Last());
                for (int i = 0; i < L.Count(); ++i)
                {
                    if (L[i].Item1 == LastItem2 && L[i].Item2 != LastItem1 && L[i].Item2 != newElement && L[i].Item2 != LastItem2) L[i] = new Tuple<string, string>(newElement, L[i].Item2);
                    else if (L[i].Item2 == LastItem1 && L[i].Item1 != LastItem1 && L[i].Item1 != newElement && L[i].Item1 != LastItem2) L[i] = new Tuple<string, string>(L[i].Item1, newElement);
                }

                var listitemsToRemove = L.Where(f => f.Item1 == LastItem1 || f.Item2 == LastItem2 || f.Item1 == LastItem2 || f.Item2 == LastItem1).ToArray();
                foreach (var item in listitemsToRemove) L.Remove(item);
                listitemsToRemove = L.Where(f => f.Item2 == LastItem2).ToArray();

            }

Answer 1

1. Its hard to read highly obfuscated code, however one thing that jumps out at me is this:

   L[i].Item1

   Which is sub-optimal as compared to a dictionary. I imagine you might want to retain ordering, in which case you can use OrderedDictionary<>

2. You use a for loop which could be optimized by a foreach loop in your cases. It is true that for loops are faster in raw performance but not in the way you are using it. You do about 12 look ups on L which is a list. Its not an array, its a list, so picking items in the middle of a list like that is going to lose speed over time. Foreach is optimized for this specific case and is faster head to head if iterating a list (unless you introduce an int counter in which case for loop is faster).

3. words[i] is doing 3 lookups (inefficiently as compared to a foreach loop) where it would look it up once