Analysis of multiple game scores
Solve with math
This is a math problem. Let say we have a competition: [a, b, c] score [5, 2, 10], this means that the scoring is:
$$
\begin{array}{|l|r|r|r|}
&amp; \textrm{a} &amp; \textrm{b} &amp; \textrm{c} &amp; \textrm{res} \\
\hline
\textrm{a} &amp; \text{NaN} &amp; 3 &amp; -5 &amp; -2 \\
\textrm{b} &amp; -3 &amp; \text{NaN} &amp; -8 &amp; -11\\
\textrm{c} &amp; 5 &amp; 8 &amp; \text{NaN} &amp; 13
\end{array}
$$
As you should be able to see, you don't need to calculate the sum again and again for each pair.
Solution:
For each team:
\$\text{team's score} \times \text{number of teams} - \text{total score}\$.
score[a] =  5 * 3 - 17 =  -2
score[b] =  2 * 3 - 17 = -11
score[c] = 10 * 3 - 17 =  13

The time complexity of this is \$O(n)\$. Calculate all pairs is \$O(n^2)\$.
Some code
Here I will save the total score for each team (not the history of the scores _  the code change for that would not be big tho).
from collections import Counter, defaultdict

# test data
games = [['A', 'B'], ['B'], ['A', 'B', 'C', 'D', 'E'], ['B'], ['A', 'B', 'C'], ['A'], ['B', 'C'], ['A', 'B'],
         ['C', 'A', 'B'], ['A'], ['B', 'C']]

gamescores = [[1.0, 5.0], [3.0], [2.0, 7.0, 3.0, 1.0, 6.0], [3.0], [5.0, 2.0, 3.0], [1.0], [9.0, 3.0], [2.0, 7.0],
              [3.0, 6.0, 8.0], [2.0], [7.0, 9.0]]

wd = defaultdict(float)

for players, scores in zip(games, gamescores):
    if len(players) == 1:
        continue
    total_sum = sum(scores)
    for player, score in zip(players, scores):
        wd[player] = wd[player] + score * len(scores) - total_sum

print(wd)

Result
defaultdict(&lt;class 'float'&gt;, {'A': -12.0, 'B': 32.0, 'C': -17.0, 'D': -14.0, 'E': 11.0})

Edit: Grouping based on last results
OP clarified that each competition affect the total score taking from the previous competition because the grouping changes.
In the example, scores: [1.0, 5.0], [3.0], [2.0, 7.0, 3.0, 1.0, 6.0], [3.0], [5.0, 2.0, 3.0], [1.0], [9.0, 3.0], teams: [a,b], [b], [a,b,c,d,e], [b], [a,b,c],
A scores as:

1st game: -4
2nd game:  0 (he was not participant)
3rd game: -6 (because at 5th game, only A, B, C are competing)

For that, we can pre-process the groups to make sure that only the competitors of next game are considered.
Pre-processing idea
That is just an example how to solve the issue using the pre-processing. Notice that is a backward thinking. Next game determines which competitors matter in terms of scoring. Therefore, the processing is done in reverse order.
def pre_process(games, gamescores):
    last_game = {}
    result = []
    for game in zip(reversed(games), reversed(gamescores)):
        game_dict = dict(zip(game[0], game[1]))
        if len(game[0]) == 1:
            result.append(game_dict)
            continue
        if len(last_game) != 0:
            union_set = set(game_dict.keys()).intersection(set(last_game.keys()))
            last_game = game_dict
            game_dict = {k: game_dict[k] for k in union_set}
        else:
            last_game = game_dict
        result.append(game_dict)
    return result


pairs = list(reversed(pre_process(games, gamescores)))
wd = defaultdict(float)
for game in pairs:
    players = list(game.keys())
    scores = [game[k] for k in players]
    if len(players) == 1:
        continue

    total_sum = sum(scores)
    for player, score in zip(players, scores):
        wd[player] += score * len(scores) - total_sum
    print(wd)