迭代遍历哈希表，求解《828. 统计子串中的唯一字符》

var uniqueLetterString = function(s) {
  const n = s.length, posMap = new Map
  for (let i = 0; i < n; i++) {
    if (posMap.has(s[i])) posMap.get(s[i]).push(i)
    else posMap.set(s[i], [-1, i])
  }
  let r = 0
  posMap.forEach(pos => {
    const m = pos.length
    pos.push(n)
    for (let i = 1; i < m; i++) {
      r += (pos[i] - pos[i - 1]) * (pos[i + 1] - pos[i]) 
    }
  })
  return r
};

function uniqueLetterString(s: string): number {
  const n = s.length, posMap = new Map
  for (let i = 0; i < n; i++) {
    if (posMap.has(s[i])) posMap.get(s[i]).push(i)
    else posMap.set(s[i], [-1, i])
  }
  let r = 0
  for (const pos of posMap.values()) {
    const m = pos.length
    pos.push(n)
    for (let i = 1; i < m; i++) {
      r += (pos[i] - pos[i - 1]) * (pos[i + 1] - pos[i])
    }
  }
  return r
};

class Solution {
  function uniqueLetterString($s) {
    $n = strlen($s);
    $posMap = array();
    for ($i = 0; $i < $n; $i++) {
      if ($posMap[$s[$i]] === null) $posMap[$s[$i]] = [-1, $i];
      else $posMap[$s[$i]] []= $i;
    }
    $r = 0;
    foreach ($posMap as $pos) {
      $m = count($pos);
      $pos []= $n;
      for ($i = 1; $i < $m; $i++) {
        $r += ($pos[$i] - $pos[$i - 1]) * ($pos[$i + 1] - $pos[$i]);
      }
    }
    return $r;
  }
}

func uniqueLetterString(s string) int {
  n, posMap, r := len(s), map[rune][]int{}, 0
  for i, c := range s {
    if _, ok := posMap[c]; ok {
      posMap[c] = append(posMap[c], i)
    } else {
      posMap[c] = []int{-1, i}
    }
  }
  for _, pos := range posMap {
    m := len(pos)
    pos = append(pos, n)
    for i := 1; i < m; i++ {
      r += (pos[i] - pos[i - 1]) * (pos[i + 1] - pos[i])
    }
  }
  return r
}

func uniqueLetterString(s string) int {
  n, posMap, r := len(s), map[rune][]int{}, 0
  for i, c := range s {
    posMap[c] = append(posMap[c], i)
  }
  for _, pos := range posMap {
    m := len(pos) + 1
    pos = append(append([]int{-1}, pos...), n)
    for i := 1; i < m; i++ {
      r += (pos[i] - pos[i - 1]) * (pos[i + 1] - pos[i])
    }
  }
  return r
}

class Solution {
  public int uniqueLetterString(String s) {
    int n = s.length(), r = 0;
    Map<Character, List<Integer>> posMap = new HashMap<Character, List<Integer>>();
    for (int i = 0; i < n; i++) {
      if (posMap.containsKey(s.charAt(i))) posMap.get(s.charAt(i)).add(i);
      else {
        List<Integer> t = new ArrayList<Integer>();
        t.add(-1);
        t.add(i);
        posMap.put(s.charAt(i), t);
      }
    }
    for (List<Integer> pos : posMap.values()) {
      int m = pos.size();
      pos.add(n);
      for (int i = 1; i < m; i++) {
        r += (pos.get(i) - pos.get(i - 1)) * (pos.get(i + 1) - pos.get(i));
      }
    }
    return r;
  }
}

public class Solution {
  public int UniqueLetterString(string s) {
    int n = s.Length, r = 0;
    Dictionary<int, IList<int>> posMap = new Dictionary<int, IList<int>>();
    for (int i = 0; i < n; i++) {
      if (posMap.ContainsKey(s[i])) posMap[s[i]].Add(i);
      else {
        IList<int> t = new List<int>();
        t.Add(-1);
        t.Add(i);
        posMap.Add(s[i], t);
      }
    }
    foreach (KeyValuePair<int, IList<int>> pair in posMap) {
      IList<int> pos = pair.Value;
      int m = pos.Count;
      pos.Add(n);
      for (int i = 1; i < m; i++) {
        r += (pos[i] - pos[i - 1]) * (pos[i + 1] - pos[i]);
      }
    }
    return r;
  }
}

typedef struct {
  int key;
  int* val;
  int i;
  UT_hash_handle hh;
} HashItem;
int uniqueLetterString(char * s){
  int n = strlen(s), r = 0;
  HashItem* posMap = NULL;
  for (int i = 0; i < n; i++) {
    HashItem* pEntry = NULL;
    int key = s[i] - '0';
    HASH_FIND_INT(posMap, &key, pEntry);
    if (pEntry == NULL) {
      pEntry = malloc(sizeof(HashItem));
      pEntry->key = s[i] - '0';
      int* val = malloc(sizeof(int) * 1e5);
      val[0] = -1;
      val[1] = i;
      pEntry->val = val;
      pEntry->i = 2;
      HASH_ADD_INT(posMap, key, pEntry);
    } else {
      (pEntry->val)[(pEntry->i)++] = i;
    }
  }
  HashItem* tmp, *cur;
  HASH_ITER(hh, posMap, cur, tmp) {
    int m = cur->i;
    int* pos = cur->val;
    pos[m] = n;
    for (int i = 1; i < m; i++) {
      r += (pos[i] - pos[i - 1]) * (pos[i + 1] - pos[i]);
    }
  }
  return r;
}

class Solution {
public:
  int uniqueLetterString(string s) {
    int n = s.size(), r = 0;
    unordered_map<char, vector<int>> posMap;
    for (int i = 0; i < n; i++) {
      if (posMap.find(s[i]) == posMap.end()) posMap.emplace(s[i], vector<int>{-1, i});
      else posMap[s[i]].emplace_back(i);
    }
    for (auto &[_, pos] : posMap) {
      int m = pos.size();
      pos.emplace_back(n);
      for (int i = 1; i < m; i++) {
        r += (pos[i] - pos[i - 1]) * (pos[i + 1] - pos[i]);
      }
    }
    return r;
  }
};

class Solution:
  def uniqueLetterString(self, s: str) -> int:
    n, posMap, r = len(s), dict(), 0
    for i, c in enumerate(s):
      if c not in posMap: posMap[c] = [-1, i]
      else: posMap[c].append(i)
    for pos in posMap.values():
      m = len(pos)
      pos.append(n)
      for i in range(1, m):
        r += (pos[i] - pos[i - 1]) * (pos[i + 1] - pos[i])
    return r