728 - LeetCode Greedy on 嗡嗡的隨手筆記

【Leetcode】python - [134] Gas Station 個人解法筆記

Mon, 20 Jun 2022 18:00:21 +0800

題目出處

134. Gas Station

難度

medium

題目分類

Array, Greedy

2022-06-20 一刷

個人範例程式碼 - 一刷 (2022/06/20)

class Solution:
    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:

        if sum(gas) < sum(cost):
            return -1

        remain_gas = 0
        start_station = 0
        for i in range(len(gas)):
            remain_gas += gas[i]
            remain_gas -= cost[i]
            if remain_gas < 0:
                # change start station
                remain_gas = 0
                start_station = i+1

        return start_station

算法說明

我們透過 0 不斷的「+ gas[i]」，移動至下一個 station 「- cost[i]」，
當發現 remain_gas 小於 0 時，表示這個加油站適合當最後一站。

(用最後剩的 gas 回到此處。)

更改 start station 位置時， start_station 的位置改為「i+1」

input handling

如果 sum(gas) < sum(cost)，不可能走完全程。
反之，一定走得完全程，至少會有一個答案。 (題目也限制了，只會有一個答案)

Boundary conditions

用 for 控制來範圍

Reference

加油站 · Gas Station

【Leetcode】python - [122] Best Time to Buy and Sell Stock II 個人解法筆記

Fri, 17 Jun 2022 18:28:56 +0800

題目出處

122. Best Time to Buy and Sell Stock II

難度

medium

題目分類

Array, Dynamic Programming, Greedy

2022-06-17 一刷

個人範例程式碼 - 一刷 (2022/06/17)

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        max_profit = 0 
        for i, price in enumerate(prices):
            if i > 0:
                one_day_profit = prices[i] - prices[i-1]
                max_profit += one_day_profit if one_day_profit >= 0 else 0

        return max_profit

算法說明

可以一天內即時的進行買賣，我們最好的收益就是「從頭到尾都沒有損失的最佳情況」，
因此我們只要計算

當「今日 - 前日受益 > 0」，我們就加上收益，
當「收益 <= 0」，我們就 +0

input handling

Boundary conditions

用 for 來控制搜尋範圍

Reference

买卖股票的最佳时机 II · Best Time to Buy and Sell Stock II

【Leetcode】python - [621] Task Scheduler 個人解法筆記

Fri, 17 Jun 2022 17:19:38 +0800

題目出處

621. Task Scheduler

難度

medium

題目分類

Array, Hash Table, Greedy, Sorting, Heap (Priority Queue), Counting

2022-06-17 一刷

個人範例程式碼 - 一刷 (2022/06/17)

class Solution:
    def leastInterval(self, tasks: List[str], n: int) -> int:
        counter = Counter(tasks)
        collect_counts = sorted(counter.values(), reverse = True)

        # same_max_length + (max_count-1) * (1+n)
        same_max_length = collect_counts.count(collect_counts[0])
        max_length = same_max_length + (collect_counts[0] - 1) * (n + 1)

        return max(max_length, len(tasks)) # min length

算法說明

這題的答案可以直接用數學公式導出來，個人認為對面試準備的幫助比較不大。

分析答案的分佈，我們可以知道「最大數量對於結果有一定程度的影響」，
而繼續往下推，我們可以知道最小長度等於 = 「同樣的最大數量」+ 「(n+1) * (最大數量 -1)」

不懂在說什麼的話，就看下圖吧：

input handling

Boundary conditions

直接數學運算出來

Reference

任务计划 · Task Scheduler

【Leetcode】python - [846] Hand of Straights 個人解法筆記

Fri, 17 Jun 2022 16:21:35 +0800

題目出處

846. Hand of Straights

難度

medium

題目分類

Array, Hash Table, Greedy, Sorting

2022-06-17 一刷

個人範例程式碼 - 一刷 (2022/06/17)

class Solution:
    def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
        if not len(hand) % groupSize == 0:
            return False

        counter = Counter(hand)
        # print(counter.items())
        for key in sorted(counter.keys()):
            if counter[key] == 0:
                continue
            if counter[key] > 0:
                num_of_cards = counter[key]
                for delta_i in range(groupSize):
                    # print(key + delta_i)
                    counter[key + delta_i] -= num_of_cards
                    if counter[key + delta_i] < 0:
                        return False

        return True

算法說明

先處理不整除的狀況，直接 return False

如果是整除的情況，我們先進行排序，
從小的卡片開始，往後「扣除最小卡片的數量」，

搜尋卡片的過程中，我們順便判斷剩餘的卡片數量是否大於 0，
等於 0 表示沒有剩餘，我們採取 continue 的動作。

input handling

先處理不整除的狀況，直接 return False

Boundary conditions

用 for 控制搜尋範圍

Reference

一手顺子 · Hand of Straights

【Lintcode】python - [919] Meeting Rooms II 個人解法筆記

Mon, 06 Jun 2022 03:22:51 +0800

題目出處

919 · Meeting Rooms II

難度

medium

題目分類

Array, Two Pointers, Greedy, Sorting, Heap (Priority Queue), Prefix Sum

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

from typing import (
    List,
)
from lintcode import (
    Interval,
)

"""
Definition of Interval:
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param intervals: an array of meeting time intervals
    @return: the minimum number of conference rooms required
    """
    def min_meeting_rooms(self, intervals: List[Interval]) -> int:
        # Write your code here
        if not intervals:
            return 0

        time_table = []
        for interval in intervals:
            time_table.append((interval.start, +1))
            time_table.append((interval.end, -1))

        time_table.sort(key=lambda x: x[0])

        ans = 0
        booked_room = 0
        for time, room_used in time_table:
            booked_room += room_used
            ans = max(ans, booked_room)

        return ans

或者，我們也可以用 hashtable 來記錄 (概念相同)

from typing import (
    List,
)
from lintcode import (
    Interval,
)

"""
Definition of Interval:
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param intervals: an array of meeting time intervals
    @return: the minimum number of conference rooms required
    """
    def min_meeting_rooms(self, intervals: List[Interval]) -> int:
        # Write your code here
        if not intervals:
            return 0

        time_table = collections.defaultdict(int)
        for interval in intervals:
            time_table[interval.start] += 1
            time_table[interval.end] -= 1


        # print(time_table)

        ans = 0
        used_room = 0
        for time in sorted(time_table.keys()):
            used_room += time_table[time]
            ans = max(ans, used_room)

        return ans

算法說明

這題目有前一題單純只判斷有沒有重複會議室，而這題是要直接計算所需要的會議室數量，上一題可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/lintcode-python-920/

現在要安排需要的會議室數量，
我們可以直接把所有的時間點 (start, end) 都存入一個 table 裡面，排序後就可以得到我們要的答案。

儲存的方式為 (start_time, +1), (end_time, +1)，
最後我們只要將第一個欄位的 time 排序即可。

之後我們可以再使用 +1, -1 去判斷個時段的會議室增減。

input handling

如果沒有 intervals, 回傳 0 (題目沒特別要求)

Boundary conditions

用 for 迴圈控制範圍

Reference

会议室 II · Meeting Rooms II

【Leetcode】python - [45] Jump Game II 個人解法筆記 #重要題型

Mon, 23 May 2022 14:38:16 +0800

題目出處

45. Jump Game II

難度

Medium

題目分類

Array, Dynamic Programming, Greedy

2022-05-23 一刷

個人範例程式碼 - 一刷 (2022/05/23)

class Solution:
    def jump(self, nums: List[int]) -> int:

        # record min jump, init
        dp = [float("inf")] * len(nums)

        dp[0] = 0 # start
        # function
        for i in range(len(nums)):
            for j in range(i+1, i+1 + nums[i]): # 1:3 = 12, 1:1 = 0
                if j < len(nums):
                    dp[j] = min(dp[j], dp[i]+1) # jump+1 from dp[i] 
                else: # over range
                    break

        # print(dp)
        return dp[-1]

        # 2 3 1 1 4
        # 1 inf inf inf inf
        # 1 1 1 inf inf
        # 1 1 1 2 2

算法說明

此題的前一題為不需要算步數的版本，只需要知道可不可抵達，可參考 (啊怎麼第二題的題號還比較前面?) ：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/leetcode-python-55/

計算步數，我們一樣使用 DP，「紀錄最小抵達該樓層時使用步數」

function: dp[i] = min(dp[i], dp[j] + 1)

我們要比較的是，第 j 樓可以一步到此(+1) 的步數，是否比原來紀錄的可能步數還要少。

init: dp[0] = 1, 其他初始化 float(“inf”) (會被比較小的步數取代)
ans: dp[-1]

DP 變化如下

# 2 3 1 1 4 
# 0 inf inf inf inf (init)
# 0 1 1 inf inf (1F)
# 0 1 1 2 2 (2F)

優化

這裡可以做一些小優化，
因為到接近終點的樓層時， i + jump 會超過終點很多，
此時我們可以「提早先 break 迴圈」 (因為超過終點的範圍都不重要)

input handling

一同在 for 裡面處理掉

Boundary conditions

用 for 來控制 DP 的範圍

Reference

跳跃游戏 II · Jump Game II

【Leetcode】python - [435] Non-overlapping Intervals 個人解法筆記

Thu, 19 May 2022 16:01:48 +0800

題目出處

435. Non-overlapping Intervals

難度

Medium

題目分類

Array, Dynamic Programming, Greedy, Sorting

2022-05-19 一刷

個人範例程式碼 - 一刷 (2022/05/19)

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        intervals.sort(key = lambda x: x[1])

        cnt = 0
        end = float("-inf")

        for i, interval in enumerate(intervals):
            if interval[0] >= end:
                end = interval[1] # update end
            else:
                cnt += 1

        return cnt

算法說明

這題我們使用的是 greedy 的作法，

我們先依照 end 來排序，
依據 greedy 的策略，我們把初始 end 設定為 -inf，

正常情況：如果每一次 start >= 前一個 end (表示無重疊)，且因為我們已經先將 end 排序，因此可以視為得到所有以 end 開頭的區間。
異常情況：start 比前一個 end 小，表示重疊了，此時我們 ans += 1，然後 continue 不理這一組 (視為會被刪掉的組合)

input handling

一同在 for loop 內處理。

Boundary conditions

用 for loop 控制範圍

Reference

无重叠区间 · Non-overlapping Intervals

【Leetcode】python - [11] Container With Most Water 個人解法筆記

Thu, 12 May 2022 03:54:28 +0800

題目出處

https://leetcode.com/problems/container-with-most-water/

難度

Medium

題目分類

Array, Two Pointers, Greedy

2022-05-12 二刷

題外話

這題與 [42] Trapping Rain Water 類似，但 42 題比較難，
或是我有想過如果水缸換成「中柱隔開不計算」，搞不好都是另外一種更難的題目。

個人範例程式碼 - 二刷 (2022/05/12)

class Solution:
    def maxArea(self, height: List[int]) -> int:
        if not height or len(height) < 2:
            return 0

        start, end = 0, len(height)-1
        # [1,8,6,2,5,4,8,3,7] = 7(8-1)*7(min([8],[1]))
        max_water = 0
        while(start < end):
            max_water = max(max_water, (end - start) * min(height[start], height[end]))
            if height[start] < height[end]: # try to find two highest side
                start += 1
            else:
                end -= 1
        else:
            max_water = max(max_water, (end - start) * min(height[start], height[end]))

        return max_water

算法說明

策略是，想辦法找到左右都是最高的，只去移動(更新)邊比較小的那側。
利用 two pointer 去找，過程中不斷更新。

input handling

如果 not height or len(height) < 2，return 0 (錯誤的狀況)

Boundary conditions

用 while(start < end) 控制搜尋的範圍。

2021-03-31 一刷

個人手繪解法筆記 (解法重點) - 2021/3/31 一刷

也因為「即使中柱隔開，照樣計算」，所以我們只要找到「兩側最高」乘上「寬度」綜合起來最大就是答案。

TwoPointers

我們用兩個指標 r, l 分別一個從左邊掃，一個從右邊掃，
從 height[r], height[l] 選比較矮的，往前走尋找更高的
(往前走也就是：r-1, l+1)

每算一次更新一次最大面積 (還好這題不用考慮中間有卡柱子的問題，簡單很多)，
掃到中止目標 (寬 = 0 或 r 小於等於 l)

個人範例程式碼 - 一刷 (2021/03/31)

class Solution:
    def maxArea(self, height: List[int]) -> int:
        max_area = 0
        l = 0 # index
        r = len(height)-1 # index
        width = len(height)-1
        while(width > 0 and l < r): # normal case
            area = width * min(height[r], height[l])
            # print(f"area = {area}, r = {r}, l = {l}") # debug
            max_area = max(max_area, area)


            # update
            if height[r] > height[l]: # l smaller
                l += 1
                width -= 1
            else:
                r -= 1
                width -= 1

        return max_area

Reference

【Leetcode】python - [2259] Remove Digit From Number to Maximize Result 個人解法筆記 | 291th LeetCode Weekly Contest

Tue, 03 May 2022 02:20:50 +0800

題目出處

2259. Remove Digit From Number to Maximize Result

難度

easy

題目分類

String, Greedy, Enumeration

2022-05-03 一刷

個人範例程式碼 - 一刷 (2022/05/03)

class Solution:
    def removeDigit(self, number: str, digit: str) -> str:
        if not number or not digit:
            return -1

        if digit not in number:
            return -1

        max_num = 0
        for i in range(len(number)):
            if number[i] == digit:
                max_num = max(max_num, int(number[:i]+number[i+1:]))

        return str(max_num)

算法說明

先來說明一下題目的意思，題目敘述有點小複雜，

簡單來說就是，digit 是我們要刪除的目標，
從原本的 number 中刪除一個 digit 使結果最大。

因為是 easy，應該窮舉直接比較大小即可。

input handling

處理 digit 不在 number 的情況， return -1
處理 not digit or not number 的情況， return -1

Boundary conditions

控制 for-loop 的範圍

Reference

python - easy solution

【Leetcode】python - [55] Jump Game 個人解法筆記

Thu, 28 Apr 2022 04:32:36 +0800

題目出處

55. Jump Game

難度

Medium

題目分類

Array, Dynamic Programming, Greedy

2022-04-28 一刷

個人範例程式碼 - 一刷 (2022/04/28)

一開始建了一個新的答案的 list

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        if len(nums) <= 1:
            return True

        max_can_reach_idx = [0 for _ in range(len(nums))]
        for i, num in enumerate(nums):
            if i == 0:
                max_can_reach_idx[0] = num+i
            if i > 0 and max_can_reach_idx[i-1] >= i:
                max_can_reach_idx[i] = max(max_can_reach_idx[i-1], num+i)

        return max_can_reach_idx[-1] > 0

後來發現可以簡化至單一個 max_idx 即可，並當發現不行時，提早 early return

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        max_idx = 0
        for i, num in enumerate(nums):
            if i > max_idx: # can not reach, first 0 > 0 
                return False
            max_idx = max(num+i, max_idx)

        return max_idx >= len(nums)-1 # 4 >= 5-1

算法說明

透過建立一個新的 list，我們紀錄

- 前一個 idx 最大可抵達的位置 - 相比前一個 idx 最大可抵達位置，看下一個位置是否能抵達，同時取 max(此位置能抵達的最遠, 上一個位置能抵達的最遠)

input handling

如果 input len <= 1，return True

Boundary conditions

後來優化的版本中，其實當發現 max_idx 已經到不了的時候，就已經可以 early return 了
第一個版本是一定會算完

Reference

1-6 lines, O(n) time, O(1) space

【Leetcode】python - [44] Wildcard Matching 個人解法筆記

Sat, 23 Apr 2022 02:05:31 +0800

題目出處

44. Wildcard Matching

難度

hard

題目分類

String, Dynamic Programming, Greedy, Recursion

2022-04-23 一刷

個人範例程式碼 - 一刷 (2022/04/23)

class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        self.memo_matched_begin = {}
        return self.dfs(s, p, 0, 0)

    def dfs(self, s, p, start_s, start_p):
        if (start_s, start_p) in self.memo_matched_begin:
            return self.memo_matched_begin[(start_s, start_p)]

        # end of recursion
        if start_s >= len(s) and start_p >= len(p):
            return True
        if start_s < len(s) and start_p >= len(p): # s left
            return False        
        if start_s >= len(s) and start_p < len(p): # p left
            for idx in range(start_p, len(p)):
                if p[idx] == "*":
                    continue
                else:
                    return False
            return True

        # define and split
        if self.is_char_matched(s[start_s], p[start_p]): # normal pattern
            ans = self.dfs(s, p, start_s+1, start_p+1)
        elif p[start_p] == "*":
            # can be nothing to anything(keep *)
            # * = nothing, self.dfs(s, p, start_s, start_p+1)
            # * = anything, self.dfs(s, p, start_s+1, start_p)
            ans = self.dfs(s, p, start_s, start_p+1) or self.dfs(s, p, start_s+1, start_p)
        else:
            ans = False

        self.memo_matched_begin[(start_s, start_p)] = ans
        return ans

    def is_char_matched(self, s, p):
        return s <mark> p or p </mark> "?"

算法說明

超難的配對問題，首先我們先不管加速，嘗試先寫一個能解的版本

基本版的寫完後，就會發現簡單的都能 pass，比較難的 case 會 TLE，
原因是因為我們的搜索時間是「指數等級」的，看來是要稍微優化一下。

記憶化搜索 (DP)

我們用一個策略紀錄我們搜尋的結果，主要因為我們進行的「重複搜尋」太多了，
我們透過記憶 start_p, start_q 的兩個起始位置，與對應結果。

當遞迴再一次回到此位置時，直接去 hashtable 拿 (start_p, start_q) 的結果來用。

這邊我們強調一下增加的部分：

拿取

if (start_s, start_p) in self.memo_matched_begin:
    return self.memo_matched_begin[(start_s, start_p)]

儲存

self.memo_matched_begin[(start_s, start_p)] = ans

於是我們就能完成這道 hard 的題目。

input handling

Boundary conditions

見上述說明

Reference

通配符匹配 · Wildcard Matching

【Leetcode】python - [763] Partition Labels 個人解法筆記

Fri, 22 Apr 2022 15:08:54 +0800

題目出處

763. Partition Labels

難度

medium

題目分類

Hash Table, Two Pointers, String, Greedy

2022-04-22 一刷

個人範例程式碼 - 一刷 (2022/04/22)

class Solution:
    def partitionLabels(self, s: str) -> List[int]:
        # partition need no word duplicate
        hashtable = self.set_hashtable(s)
        # print(hashtable)
        intervals = self.set_interval(hashtable)
        # print(intervals)
        intervals = self.merge_interval(intervals)
        # print(intervals)
        return [interval[1]-interval[0]+1 for interval in intervals] # 0~2 = 2-0+1

    def set_interval(self, hashtable):
        return [interval for interval in hashtable.values()]

    def merge_interval(self, intervals):
        ans = []

        for idx, interval in enumerate(intervals):
            if idx == 0:
                start = interval[0]
                end = interval[1]
            else:
                if end >= interval[0]:
                    end = max(interval[1], end)                    
                else: # no cross interval
                    ans.append([start, end])
                    start = interval[0]
                    end = interval[1]

        ans.append([start, end]) # last interval
        return ans

    def set_hashtable(self, s):
        hashtable = {}
        for idx, word in enumerate(s):
            if word not in hashtable:
                hashtable[word] = [idx, idx]
            else:
                hashtable[word][1] = idx
        return hashtable

算法說明

這題是 interval 系列的變化題，我們可以建立一個 hashtable，
紀錄每一個單字的 [起始, 結束] 位置。

最後因為題目要求最大化 interval 數量，但需要盡量保持不重複數字
(這邊直接就當作同一個字母，「不能出現在不同區間啦！」題目敘述太繞了!)

因此，我們先用文字組出每一個區間，然後合併區間。就是一個這樣的題目了!

討論 interval 合併的策略

主要情況有兩種：

先固定好 start 的順序，
假設後進來的 [interval[0], interval[1]]

有要合併的條件： end >= interval[0]

而合併後，有分為兩種情況：

- interval[1] >= end：類似交錯的情況，合併區間變為 [start, interval[1]] - end >= interval[1]：類似包起來的情況，合併區間變為 [start, end]

以上的 1，2 又可以合併變為 [start, max(interval[1], end)]

input handling

Boundary conditions

見上述說明

Reference

https://www.facebook.com/groups/1451299754892511/posts/5171314816224301/

【Leetcode】python - [2244] Minimum Rounds to Complete All Tasks 個人解法筆記 | 289th LeetCode Weekly Contest

Sun, 17 Apr 2022 17:42:19 +0800

題目出處

2244. Minimum Rounds to Complete All Tasks

難度

medium

題目分類

Array, Hash Table, Greedy, Counting

2022-04-17 一刷

個人範例程式碼 - 一刷 (2022/04/17)

class Solution:
    def minimumRounds(self, tasks: List[int]) -> int:
        # 1: -1 round
        # 2: 1 round
        # 3: 2 rounds
        # 3k: k rounds
        # 3k+1: 4=3(k-1)+2+2, k+1 times
        # 3k+2: 5=3(1)+2, k+1 times
        counters = Counter(tasks)
        ans = 0
        for num_of_task in counters.values():
            if num_of_task <= 1:
                return -1
            else:
                # 3 = 1 
                # 4 = 2
                # 5 = 2
                # 6 = 2
                ans += (num_of_task+2)//3
        return ans

算法說明

這題考的是數學歸納法的概念，比較是數學的範圍

我們推論：

1: -1 round
2: 1 round
3: 2 rounds
3k: k rounds
3k+1: 4=3(k-1)+2+2, k+1 times
3k+2: 5=3(1)+2, k+1 times

而為了計算方便，我們可以做一些使計算上方便的技巧。

3 = 1
4 = 2
5 = 2
6 = 2

我們透過移動 k+2 使得 // 3 後能夠直接得到我們要的數字。

input handling

Boundary conditions

只要發現其中一個任務不可能執行完成，提早 return -1。

Reference

[Java/C++/Python] Sum up (freq + 2) / 3

【Leetcode】python - [680] Valid Palindrome II 個人解法筆記

Wed, 06 Apr 2022 20:17:11 +0800

題目出處

680. Valid Palindrome II

難度

easy

題目分類

Two Pointers, String, Greedy

2022-04-06 一刷

個人範例程式碼 - two pointers

class Solution:
    def validPalindrome(self, s: str) -> bool:
        start, end = 0, len(s) - 1 
        while(start < end):
            if(s[start] == s[end]): # same
                start += 1
                end -= 1
            else: # not same, try cut one
                return self.is_palindrome(s, start+1, end) or self.is_palindrome(s, start, end-1) 

        return True

    def is_palindrome(self, s, start, end):
        while(start < end):
            if (s[start] == s[end]):
                start += 1
                end -= 1
            else:
                return False
        return True

算法說明

這題可以用比較聰明的作法，
我們既然都知道我們會需要「多次判斷」是否是「回文」，

我們可以先寫好判斷回文的 function 「is_palindrome」，
讓我們的主程式可以多次的去 call。

而刪除的概念可以理解為，如果我們找到兩端各一個「非相同的文字」，
我們就嘗試「左邊」與「右邊」都去掉嘗試判斷看看，
因為只要判斷一次刪除，因此如果回傳都沒有解，即為最終無解的情況。

input handling

處理沒有 input 的狀況，內建 start < end 條件可以處理

Boundary conditions

start < end，交錯或等於就結束

Reference

有效回文 II · Valid Palindrome II

【Leetcode】python - [409] Longest Palindrome 個人解法筆記

Wed, 30 Mar 2022 21:36:02 +0800

題目出處

409. Longest Palindrome

難度

easy

題目分類

Hash Table, String, Greedy

2022-03-30 一刷

個人範例程式碼 - 一刷 (2022/03/30)

class Solution:
    def longestPalindrome(self, s: str) -> int:
        if not s: # input handling
            return 0

        ans = 0
        contains_odd = 0
        word_counter = self.counter(s) # 直接使用等同於 collections.Counter(s)，就不用另外自己寫 counter
        for key, value in word_counter.items():
            if value % 2 == 0:
                ans += value
            else:
                ans = ans + value - 1
                if contains_odd:
                    pass
                else:
                    contains_odd = 1

        return ans + contains_odd

    def counter(self, s):
        counter = {}
        for char in s:
            if char not in counter:
                counter[char] = 1
            else:
                counter[char] += 1

        return counter

算法說明

原本想要直接用 counter 把這題爆出來，後來發現 Lintcode 似乎沒有內建這種東西，我就自己重寫了一個

另外要注意的事情：

當偶數的時候，直接加上去
當奇數的時候，-1後加上去，並保留最多一個中心點。

input handling

注意沒有輸入的時候的處理，input 為空白的時候 return 個 0 給他

Boundary conditions

我們這題沒辦法，「一定要把每個元素都看過」，至少 O(n)，