騰訊算法筆試：2019/08/17

1. 修柵欄（連續k個子序列和最小）

輸入：
7 3
1 2 6 1 1 7 1

輸出：
3

說明：

從第三個位置開始拔欄桿拔掉的長度最小為8

分析：

1. 這個題是變相的求解長度為k的連續子序列和最小時，序列的起始位置
2. 需要注意的是：隨着遍歷，不斷變化的變量有：_sum：長度為k 的子序列的和， _min：只有符合條件時，才會變化

import sys

if __name__ == '__main__':
    n, k = map(int, sys.stdin.readline().split(" "))
    h = list(map(int, sys.stdin.readline().split(" ")))

    _min = sum(h[:k])
    flag = 1
    _sum = _min
    for i in range(k, n):
        _sum = _sum + h[i] - h[i - k]
        if _sum < _min:
            _min = _sum
            flag = i - k + 2
    print(flag)

 2. 小Q玩游戲

輸入：
2
4 6
X...XX
...XX.
.X..X.
......
1 6
2 2
9 47
....X.X.X.X...X..X.....X..X..X..X....X.X...X..X
XX..X...X.........X...X...X..X.XX......X...X...
..XX...X.......X.....X.....X.XX..X.....X..XX...
.X...XX....X...X.......X.X...X......X.X.X......
X......X..X.XXX....X...X.X.XX..X.......X....X.X
....XX.X...X.XXX.X..XX.XXX...XXX..XX.X.X.XX..XX
.........X...X.XXXX...XX.XX....XX..X...X....X..
.............X....XXXX....X.X...XX.XX.X.X..X...
.X......X.....X......X......X.X.X..X.......XXX.
2 34
7 30

輸出：
YES
NO

分析：

1. 題中：“.” 表示沒有被破壞的方塊，“X”：表示已經被破壞的方塊。已經被破壞的方塊走一次就會碎掉（不能再走了），沒有被破壞的方塊可以走2次。 為了方便，在輸入時做一個映射，maps = {"."：2， ”X"：1 }
2. “.”：可以走兩次， “X”：只能走一次（不能再走了）：即，當走到該位置時，如果 符號是“.” ,將“.” 更換成“X”, 繼續走；如果符號是“X”， 終止不能再走了。即，2 能走， 1不能走。

import sys
import numpy as np

# 全局變量：上右下左，橫縱坐標的偏移量
dx, dy = [-1, 0, 1, 0], [0, 1, 0, -1]

# 找路徑
def find(n, m, sig, begin, end, x, y):
    # 走到最后一個格子，並且踩碎
    sig[x][y] -= 1
    if x == end[0]-1 and y == end[1]-1 and sig[x][y] == 1: return True
    # 開始上下左右搜索
    for i in range(4):
        a, b = x+dx[i], y+dy[i]
        if 0<= a < n and 0<= b < m and sig[a][b] == 2:
            if find(n, m, sig, begin, end, a, b):
                return True
    # 走到這，說明走不通(還原)
    sig[x][y] += 1
    return False

if __name__ == '__main__':
    nms, sigs, begins, ends = [], [], [], []
    maps = {".": 2, "X": 1}
    # 輸入
    t = int(sys.stdin.readline().strip("\n"))  # t組測試
    for i in range(t):
        n, m = map(int, sys.stdin.readline().split(" "))
        nms.append([n, m])
        sig = []
        for _ in range(n):
            line = sys.stdin.readline().strip("\n")
            sig.append(list(map(lambda i:maps[i], line)))  # 映射轉換
        sigs.append(sig)
        begins.append(list(map(int, sys.stdin.readline().split(" "))))
        ends.append(list(map(int, sys.stdin.readline().split(" "))))
    # 測試
    for i in range(t):
        n, m = nms[i]
        sig = sigs[i]
        # print("sig = \n{}".format(np.array(sig)))
        begin, end = begins[i], ends[i]
        if find(n, m, sig, begin, end, begin[0]-1, begin[1]-1):
            print("YES")
        else:
            print("NO")

3. 冰激凌配料

輸入：

3 10
2 5 3
2 1 3

輸出：

4

說明：

# 4 (7)
# 5 (12)
# 6 (18)
# 7 (24)

 分析：

1. 這題對時間復雜度有要求，如果只是單純的暴力求解的話，只能過20%
2. 需要精簡中間計算和遍歷環節
3. 則，將 w 和 v 按照數量 w 進行排序，從小到大開始累加

 

def maxGet(money, goods, prices):
    get = min(goods)  # 現在儲存能成產的量
    goods = list(map(lambda x:x-get, goods))  # 更新庫存
    # 將goods, prices 按照庫存剩余量排序
    goods, prices = zip(*sorted(zip(goods, prices)))  
    goods, prices = list(goods), list(prices)
    goods.append(float("inf"))  # 添加哨兵
    index = cost = 0
    while True:
        # 補齊index和index+1之間的差距
        gap = goods[index+1] - goods[index]  
        cost += prices[index]
        if gap * cost < money:
            money -= gap * cost
            get += gap
            index += 1
        else:
            get += money // cost
            break
    return get

import sys
if __name__ == '__main__':
    n, m = map(int, sys.stdin.readline().split(" "))
    w = list(map(int, sys.stdin.readline().split(" ")))
    v = list(map(int, sys.stdin.readline().split(" ")))
    print(maxGet(m, w, v))

4. 飛機航線

輸入：
3 5 3
1 2 7
2 3 6
1 3 9
2 1 2
3 1 1
1 2 3 8
2 3 3 1
2 1 3 5

輸出：
8
8
9

 分析：

我個人理解是：

1. 建立一個n*n的關系矩陣arr，arr[i][j] 表示飛機從城市i直接飛往城市 j 的機票價格（即，帶權值矩陣---圖）
2. 求解從城市1到城市n之間的最小距離
3. 最小路徑問題的求解方法，一般有：迪傑斯特拉算法、佛洛依德算法、廣度優先遍歷。
4. （目前代碼還沒有完全調試正確，后續補上代碼環節）

5. 探險

輸入：
6
1 2 3
8 9 10
5 0 5
-9 -8 -10
0 1 2
5 4 6

輸出：
27

說明：
小Q走 3-> 10 -> 0 -> -9 -> 0 -> 5 這條路徑得到最高的分數，其中 -9 將取相反數，得 9 分

 分析：

1. 遇見0，取相反數，這道題的最終目標是取最大，所以需要同時記錄opt_min和opt_max
2. opt_max[ i ][ j ]：表示走到該位置最大的分數
3. opt_min[ i ][ j ]：表示走到該位置最小的分數

 

import sys
import numpy as np
import copy

def maxScore(n, scores):
    # opt_max[i][j]：表示走到該位置最大的分數
    # opt_min[i][j]：表示走到該位置最小的分數
    opt_max = [[0 for _ in range(3)] for _ in range(n)]
    opt_max[0][:] = scores[0][:]  # 初始化起始位置
    opt_min = copy.deepcopy(opt_max)  # 深層拷貝
    for i in range(1, n):
        # j = 0
        if scores[i][0] == 0:
            opt_max[i][0] = -min(opt_min[i-1][0], opt_min[i-1][1])
            opt_min[i][0] = -max(opt_max[i-1][0], opt_max[i-1][1])
        else:
            opt_max[i][0] = max(opt_max[i-1][0], opt_max[i-1][1]) + \
            scores[i][0]
            opt_min[i][0] = min(opt_min[i-1][0], opt_min[i-1][1]) + \
            scores[i][0]
        # j = 1
        if scores[i][1] == 0:
            opt_max[i][1] = -min(opt_min[i-1][0], opt_min[i-1][1], \
             opt_min[i-1][2])
            opt_min[i][1] = -max(opt_max[i-1][0], opt_max[i-1][1],  \
            opt_max[i-1][2])
        else:
            opt_max[i][1] = max(opt_max[i-1][0], opt_max[i-1][1], \
            opt_max[i-1][2]) + scores[i][1]
            opt_min[i][1] = min(opt_min[i-1][0], opt_min[i-1][1], \
            opt_min[i-1][2]) + scores[i][1]
        # j = 2
        if scores[i][2] == 0:
            opt_max[i][2] = -min(opt_min[i-1][1], opt_min[i-1][2])
            opt_min[i][2] = -max(opt_max[i-1][1], opt_max[i-1][2])
        else:
            opt_max[i][2] = max(opt_max[i-1][1], opt_max[i-1][2]) + \
            scores[i][2]
            opt_min[i][2] = min(opt_min[i-1][1], opt_min[i-1][2]) + \
            scores[i][2]
    # print(np.array(opt_max))
    # print(np.array(opt_min))
    return max(opt_max[-1])


if __name__ == '__main__':
    n = int(sys.stdin.readline().strip("\n"))
    scores = []
    for i in range(n):
        scores.append(list(map(int, sys.stdin.readline().split(" "))))
    print(maxScore(n, scores))