同構字串

一對字串 字母間需要唯一的對映關係，使用雜湊表可以找到key-value對映關係 從s到t 和 t到s 都需要唯一對映 需要用一個表儲存s到t的對映，另一個表儲存t中已經被對映過的字母

def isIsomorphic(self, s, t):
        k = list(s)
        v = list(t)
        m = len(k)
        n = len(v)
        if m!=n:
            return False
        d = {}
        s = set()
        for i in range
 
(len(k)):
            if k[i] in d:
                if d[k[i]]!=v[i]:
                    return False
            else:
                if v[i] in s:
                    return False
                else:
                    s.add(v[i])
                    d[k[i]] = v[i]
        return True
        
 

兩個列表的最小索引總和

開始選擇遍歷list1，在list2中查詢list1元素，然後返回對應的index。返回陣列中保留索引和較小的結果，由於進行了列表中查詢和定位2次查詢操作，執行時間較長。 改為先將list2中項存入字典中，對字典進行查詢。速度有了較大提高

    def findRestaurant(self, list1, list2):
        ret = []
        m = {}
        min_index = 2000
        for i,s in enumerate(list2):
            m[s] = i
        for
 
 i,s in enumerate(list1):
            if s in m:
                index = m[s]
                cur_index = index+i
                if cur_index<min_index:
                    min_index = cur_index
                    ret = [s]
                elif cur_index==min_index:
                    ret.append(s)
        return ret

字串中的第一個唯一字元

用字典記錄每個字元是否重複出現過。

def firstUniqChar(self, s):
        l = [0]* len(s)
        m = {}
        s1 = list(s)
        for i,string in enumerate(s1):
            if string in m:
                l[i] = 1
                l[m[string]] = 1
            else:
                m[string] = i
        for i,flag in enumerate(l):
            if flag == 0:
                return i
        return -1

有效的數獨

劃分行列塊，記錄是否已出現

 def isValidSudoku(self, board):
        rows = [{} for i in range(9)]
        column = [{} for j in range(9)]
        block = [{} for k in range(9)]
        for i,row in enumerate(board):
            for j,num in enumerate(row):
                if num != '.':
                    k = (i//3)*3+j//3
                    if num in rows[i] or num in column[j] or num in block[k]:
                        return False
                    else:
                        rows[i][num]=i
                        column[j][num]=j
                        block[k][num]=k
        return True

字母異位詞分組

以排序後的字元為key 判斷是否相同

def groupAnagrams(self, strs):
        ret = []
        map = {}
        for s in strs:
            key = "".join(sorted(s))
            if key in map:
                i = map[key]
                ret[i].append(s)
            else:
                map[key] = len(ret)
                ret.append([s])
        return ret

總結

1.利用set可以儲存不重複元素，用於查重 2.字典key-value 可以儲存兩元素的對映關係 也可以value記錄元素的資訊 3.以排序後的陣列或字串為key;用下標，偏移量為key 4.陣列已知下標時 查詢為O(1) 利用字典儲存下標