2018-10-09,22點58

#下面這一段用一個txt來保存input的信息來模擬input.最後提交代碼時候刪除這一段即可.
a9999=open(‘1.txt‘,‘r‘)
def input():
    return a9999.readline().rstrip(‘\n‘)

#輸入數據的一些模板
# n,a=map(int,input().split())

# arr=[int(i)for i in input().split()]

# 格式化輸出
# print(‘%.2f‘%(maxi/2))
‘‘‘
#
最大公約數用
import fractions
fractions.gcd(a,b)

 
‘‘‘

    






‘‘‘
[編程題] 小易的升級之路
時間限制：1秒
空間限制：32768K
#小易經常沈迷於網絡遊戲.有一次,他在玩一個打怪升級的遊戲,他的角色的初始能力值為 a.在接下來的一段時間內,他將會依次遇見n個怪物,每個怪物的防禦力為b1,b2,b3...bn. 如果遇到的怪物防禦力bi小於等於小易的當前能力值c,那麽他就能輕松打敗怪物,並 且使得自己的能力值增加bi;如果bi大於c,那他也能打敗怪物,但他的能力值只能增加bi 與c的最大公約數.那麽問題來了,在一系列的鍛煉後,小易的最終能力值為多少?

輸入描述:
對於每組數據,第一行是兩個整數n(1≤n<100000)表示怪物的數量和a表示小易的初始能力值.
第二行n個整數,b1,b2...bn(
 
1≤bi≤n)表示每個怪物的防禦力




import fractions

while 1:#處理多段不知道多少的輸入用這個方法死循環+內層try except break套路
    try:
        now=input()
        if now==‘‘:
            break
        n,a=map(int,now.split())




        for i in range((n)):
            b=int(input())
            if b<=a:
                a+=b
            
 
else:
                a+=fractions.gcd(a,b)
        print(a)
    except:
        break    




‘‘‘
‘‘‘
[編程題] 炮臺攻擊
時間限制：1秒
空間限制：32768K
蘭博教訓提莫之後,然後和提莫討論起約德爾人,談起約德爾人,自然少不了一個人,那 就是黑默丁格------約德爾人歷史上最偉大的科學家. 提莫說,黑默丁格最近在思考一個問題:黑默丁格有三個炮臺,炮臺能攻擊到距離它R的敵人 (兩點之間的距離為兩點連續的距離,例如(3,0),(0,4)之間的距離是5),如果一個炮臺能攻擊 到敵人,那麽就會對敵人造成1×的傷害.黑默丁格將三個炮臺放在N*M方格中的點上,並且給出敵人 的坐標. 問:那麽敵人受到傷害會是多大?

輸入描述:
第一行9個整數,R,x1,y1,x2,y2,x3,y3,x0,y0.R代表炮臺攻擊的最大距離,(x1,y1),(x2,y2), (x3,y3)代表三個炮臺的坐標.(x0,y0)代表敵人的坐標.


輸出描述:
輸出一行,這一行代表敵人承受的最大傷害,(如果每個炮臺都不能攻擊到敵人,輸出0×)

輸入例子1:
1 1 1 2 2 3 3 1 2

輸出例子1:
2x







while 1:
    try:

        r,x1,y1,x2,y2,x3,y3,x0,y0=map(int,input().split())
        count=0
        if ((x1-x0)**2+(y1-y0)**2)**0.5<=r:
            count+=1
        if ((x2-x0)**2+(y2-y0)**2)**0.5<=r:
            count+=1
        if ((x3-x0)**2+(y3-y0)**2)**0.5<=r:
            count+=1
        print(str(count)+‘x‘)
    except:
        break



‘‘‘







‘‘‘
https://www.nowcoder.com/test/question/fe6c73cb899c4fe1bdd773f8d3b42c3d?pid=970447&tid=19242023


牛客網的網站有問題,搜索試卷是出不來的,只能按照連接點進去才行.
[編程題] 掃描透鏡
時間限制：1秒
空間限制：32768K
在N*M的草地上,提莫種了K個蘑菇,蘑菇爆炸的威力極大,蘭博不想貿然去闖,而且蘑菇是隱形的.只 有一種叫做掃描透鏡的物品可以掃描出隱形的蘑菇,於是他回了一趟戰爭學院,買了2個掃描透鏡,一個 掃描透鏡可以掃描出(3*3)方格中所有的蘑菇,然後蘭博就可以清理掉一些隱形的蘑菇. 問:蘭博最多可以清理多少個蘑菇?
註意：每個方格被掃描一次只能清除掉一個蘑菇。 
輸入描述:
第一行三個整數:N,M,K,(1≤N,M≤20,K≤100),N,M代表了草地的大小;
接下來K行,每行兩個整數x,y(1≤x≤N,1≤y≤M).代表(x,y)處提莫種了一個蘑菇.
一個方格可以種無窮個蘑菇.


輸出描述:
輸出一行,在這一行輸出一個整數,代表蘭博最多可以清理多少個蘑菇.

掃描2次,每一次都找最多的那個3*3進行轟炸即可

地圖問題都先加一圈邊界,邊界上炸彈設置數量為0


#這題目雖然簡單,但學到了很多地圖上的技巧



while 1:
    try:
        n,m,k=map(int,input().split())
        save=[[0]*(m+2) for i in range(n+2)]
        for i in range((k)):
            a,b=map(int,input().split())

            save[a][b]+=1

        def search(i,j):
            #返回save上i,j位置3*3內有多少個地方有地雷
            count=0
            #先把轉移坐標寫成列表
            arr=[(-1,-1),(-1,0),(-1,1),(0,-1),(0,0),(0,1),(1,-1),(1,0),(1,1)]
            for _ in range(len(arr)):
                newdex=i+arr[_][0],j+arr[_][1]

                if save[newdex[0]][newdex[1]]>0:
                    count+=1
            return count
        def jian(i,j):
            #清楚save上i,j位置3*3內每一個地方的一個地雷

            #先把轉移坐標寫成列表
            arr=[(-1,-1),(-1,0),(-1,1),(0,-1),(0,0),(0,1),(1,-1),(1,0),(1,1)]
            for _ in range(len(arr)):
                newdex=i+arr[_][0],j+arr[_][1]
                if save[newdex[0]][newdex[1]]>0:
                    save[newdex[0]][newdex[1]]-=1
        #地圖實際範圍是從1到n 從1到m
        maxi=0
        for i in range(1,(n+1)):
            for j in range(1,(m+1)):

                if search(i,j)>maxi:
                    now=i,j
                    maxi=search(i,j)
        jian(now[0],now[1])
        maxi2=0
        for i in range((n+1)):
            for j in range((m+1)):
                if search(i,j)>maxi2:
                    now=i,j
                    maxi2=search(i,j)
        print(maxi+maxi2)
    except:
        break











‘‘‘





‘‘‘
https://www.nowcoder.com/test/question/cee98a512ec246a2918ea8121f7612c8?pid=710847&tid=19243264
[編程題] 獎學金
時間限制：1秒
空間限制：32768K
小v今年有n門課，每門都有考試，為了拿到獎學金，小v必須讓自己的平均成績至少為avg。每門課由平時成績和考試成績組成，滿分為r。現在他知道每門課的平時成績為ai ,若想讓這門課的考試成績多拿一分的話，小v要花bi 的時間復習，不復習的話當然就是0分。同時我們顯然可以發現復習得再多也不會拿到超過滿分的分數。為了拿到獎學金，小v至少要花多少時間復習。

輸入描述:
第一行三個整數n,r,avg(n大於等於1小於等於1e5，r大於等於1小於等於1e9,avg大於等於1小於等於1e6)，接下來n行，每行兩個整數ai和bi，均小於等於1e6大於等於1


輸出描述:
一行輸出答案。

輸入例子1:
5 10 9
0 5
9 1
8 1
0 1
9 100

輸出例子1:
43


應該是貪心法.從收益最高的開始學習



while 1:
    try:
        n,r,avg=map(int,input().split())
        save=[]
        for i in range((n)):
            save.append([int(i)for i in input().split()][::-1])
        needall=avg*n
        save.sort()

        now=0
        for i in range(len(save)):
            now+=save[i][1]
        #print(now)#目前總分
        study=0
        for i in range(len(save)):
            if now<needall:
                if now+r-save[i][1]<=needall:
                    study+=save[i][0]*(r-save[i][1])
                    now+=r-save[i][1]
                else:
                    study+=save[i][0]*(needall-now)
                    now+=needall-now
            else:
                break
        print(study)
    except:
            break





‘‘‘
‘‘‘

https://www.nowcoder.com/question/next?pid=710847&qid=26023&tid=19243264
[編程題] 路燈
時間限制：1秒
空間限制：32768K

...........................
0     a1        a2       1

一條長l的筆直的街道上有n個路燈，若這條街的起點為0，終點為l，第i個路燈坐標為ai ，每盞燈可以覆蓋到的最遠距離為d，為了照明需求，所有燈的燈光必須覆蓋整條街，但是為了省電，要使這個d最小，請找到這個最小的d。

輸入描述:
每組數據第一行兩個整數n和l（n大於0小於等於1000，l小於等於1000000000大於0）。第二行有n個整數(均大於等於0小於等於l)，為每盞燈的坐標，多個路燈可以在同一點。


輸出描述:
輸出答案，保留兩位小數。

輸入例子1:
7 15
15 5 3 7 9 14 0

輸出例子1:
2.50

排序後間距相鄰的間距最遠的兩個燈的距離除以2即可.




while 1:
    try:
        n,l=map(int,input().split())
        arr=[int(i)for i in input().split()]
        
        arr.sort()
        maxi=0
        for i in range(len(arr)-1):
            if arr[i+1]-arr[i]>maxi:
                maxi=arr[i+1]-arr[i]
        maxi=maxi/2
        if 0 not in arr:
            first=arr[0]-0
            maxi=max(maxi,first)
        if l not in arr:
            end=l-arr[-1]
            maxi=max(maxi,end)

        print(‘%.2f‘%(maxi))
    except:
        break


‘‘‘





‘‘‘
[編程題] 牛牛找工作
時間限制：2秒
空間限制：65536K
為了找到自己滿意的工作，牛牛收集了每種工作的難度和報酬。牛牛選工作的標準是在難度不超過自身能力值的情況下，牛牛選擇報酬最高的工作。在牛牛選定了自己的工作後，牛牛的小夥伴們來找牛牛幫忙選工作，牛牛依然使用自己的標準來幫助小夥伴們。牛牛的小夥伴太多了，於是他只好把這個任務交給了你。 
輸入描述:
每個輸入包含一個測試用例。
每個測試用例的第一行包含兩個正整數，分別表示工作的數量N(N<=100000)和小夥伴的數量M(M<=100000)。
接下來的N行每行包含兩個正整數，分別表示該項工作的難度Di(Di<=1000000000)和報酬Pi(Pi<=1000000000)。
接下來的一行包含M個正整數，分別表示M個小夥伴的能力值Ai(Ai<=1000000000)。
保證不存在兩項工作的報酬相同。


輸出描述:
對於每個小夥伴，在單獨的一行輸出一個正整數表示他能得到的最高報酬。一個工作可以被多個人選擇。

輸入例子1:
3 3 
1 100 
10 1000 
1000000000 1001 
9 10 1000000000

輸出例子1:
100 
1000 
1001

1



把工作按照難度升序排列,然後數組的第二列是收入,收入裏面如果有降序的就刪除後面這一項.
用2分為每一個人找工作
‘‘‘


‘‘‘
[編程題] 被3整除
時間限制：1秒
空間限制：32768K
小Q得到一個神奇的數列: 1, 12, 123,...12345678910,1234567891011...。

數列是:0 1 1 0 1 1 011.................
顯然是011循環的.所以根據r直接就能算1到r有多少個被3整除的數

並且小Q對於能否被3整除這個性質很感興趣。
小Q現在希望你能幫他計算一下從數列的第l個到第r個(包含端點)有多少個數可以被3整除。

輸入描述:
輸入包括兩個整數l和r(1 <= l <= r <= 1e9), 表示要求解的區間兩端。


輸出描述:
輸出一個整數, 表示區間內能被3整除的數字個數。

輸入例子1:
2 5

輸出例子1:
3

例子說明1:
12, 123, 1234, 12345...
其中12, 123, 12345能被3整除。



l,r =map(int,input().split())
left=r %3
if left==1:
    left=0
if left==2:
    left=1
daor=r//3*2+left
left=(l-1) %3
if left==1:
    left=0
if left==2:
    left=1
daol=(l-1)//3*2+left
print(daor-daol)


‘‘‘


























‘‘‘
[編程題] 安置路燈
時間限制：1秒
空間限制：32768K
小Q正在給一條長度為n的道路設計路燈安置方案。
為了讓問題更簡單,小Q把道路視為n個方格,需要照亮的地方用‘.‘表示, 不需要照亮的障礙物格子用‘X‘表示。
小Q現在要在道路上設置一些路燈, 對於安置在pos位置的路燈, 這盞路燈可以照亮pos - 1, pos, pos + 1這三個位置。
小Q希望能安置盡量少的路燈照亮所有‘.‘區域, 希望你能幫他計算一下最少需要多少盞路燈。

輸入描述:
輸入的第一行包含一個正整數t(1 <= t <= 1000), 表示測試用例數
接下來每兩行一個測試數據, 第一行一個正整數n(1 <= n <= 1000),表示道路的長度。
第二行一個字符串s表示道路的構造,只包含‘.‘和‘X‘。


輸出描述:
對於每個測試用例, 輸出一個正整數表示最少需要多少盞路燈。

輸入例子1:
2
3
.X.
11
...XX....XX

輸出例子1:
1
3


算法:遇到.就用一個燈放在這個.的後面.所以當前位置就+3
遇到x就不放燈,直接位置+1.不好說清楚為什麽這麽放最少.



n=int(input())
for i in range((n)):
    chang=int(input())
    lu=input()
    dex=0
    count=0

    while dex<len(lu):
        if lu[dex]==‘.‘:
            count+=1
            dex+=3
        else:
            dex+=1
    print(count)





‘‘‘






‘‘‘
[編程題] 迷路的牛牛
時間限制：1秒
空間限制：32768K
牛牛去犇犇老師家補課，出門的時候面向北方，但是現在他迷路了。雖然他手裏有一張地圖，但是他需要知道自己面向哪個方向，請你幫幫他。 
輸入描述:
每個輸入包含一個測試用例。
每個測試用例的第一行包含一個正整數，表示轉方向的次數N(N<=1000)。
接下來的一行包含一個長度為N的字符串，由L和R組成，L表示向左轉，R表示向右轉。


輸出描述:
輸出牛牛最後面向的方向，N表示北，S表示南，E表示東，W表示西。

輸入例子1:
3
LRR

輸出例子1:
E




n=int(input())
a=input()
arr=‘NESW‘



count=0
for i in range(len(a)):
    if a[i]==‘L‘:
        count-=1
    else:
        count+=1
count=(count+4*abs(count))%4
print(arr[count])


‘‘‘





‘‘‘
[編程題] 數對
時間限制：1秒
空間限制：32768K
牛牛以前在老師那裏得到了一個正整數數對(x, y), 牛牛忘記他們具體是多少了。
但是牛牛記得老師告訴過他x和y均不大於n, 並且x除以y的余數大於等於k。
牛牛希望你能幫他計算一共有多少個可能的數對。

輸入描述:
輸入包括兩個正整數n,k(1 <= n <= 10^5, 0 <= k <= n - 1)。


輸出描述:
對於每個測試用例, 輸出一個正整數表示可能的數對數量。

輸入例子1:
5 2                            5 3    y一定大於k  (3,4)  (3,5) (4,5)

輸出例子1:
7

例子說明1:
滿足條件的數對有(2,3),(2,4),(2,5),(3,4),(3,5),(4,5),(5,3)
Python3(3.5.2)重置自測

1
?不會:


答案:
def find_pairs():
    n, k = map(int, raw_input().split())
    cnt = 0
    if k == 0:
        return pow(n, 2)
    for i in range(k + 1, n+1):
        //表示每i個數會出現一些需要的數,最後加上尾巴即可.
        cnt += n // i * (i - k) + (n % i - k + 1 if n % i >= k else 0)
    return cnt
 
print find_pairs()

‘‘‘





‘‘‘
https://www.nowcoder.com/question/next?pid=9763997&qid=152612&tid=19266166
[編程題] 矩形重疊
時間限制：1秒
空間限制：32768K
平面內有n個矩形, 第i個矩形的左下角坐標為(x1[i], y1[i]), 右上角坐標為(x2[i], y2[i])。
如果兩個或者多個矩形有公共區域則認為它們是相互重疊的(不考慮邊界和角落)。
請你計算出平面內重疊矩形數量最多的地方,有多少個矩形相互重疊。

輸入描述:
輸入包括五行。
第一行包括一個整數n(2 <= n <= 50), 表示矩形的個數。
第二行包括n個整數x1[i](-10^9 <= x1[i] <= 10^9),表示左下角的橫坐標。
第三行包括n個整數y1[i](-10^9 <= y1[i] <= 10^9),表示左下角的縱坐標。
第四行包括n個整數x2[i](-10^9 <= x2[i] <= 10^9),表示右上角的橫坐標。
第五行包括n個整數y2[i](-10^9 <= y2[i] <= 10^9),表示右上角的縱坐標。


輸出描述:
輸出一個正整數, 表示最多的地方有多少個矩形相互重疊,如果矩形都不互相重疊,輸出1。

輸入例子1:
2
0 90
0 90
100 200
100 200

輸出例子1:
2





把每一個矩陣的4個邊都看成4條無限長直線.
最後需要的區域一定是被4條直線加起來的區域.

別人答案:
import sys
lines = sys.stdin.readlines()
n = int(lines[0])
x1 = list(map(int,lines[1].split()))
y1 = list(map(int,lines[2].split()))
x2 = list(map(int,lines[3].split()))
y2 = list(map(int,lines[4].split()))
 
res = 1
for x in x1+x2:#所有的橫坐標切分點
    for y in y1+y2:#所有的縱坐標切分店
        cnt = 0
        for i in range(n):
            #在所有的橫縱切分點裏面,如果這個切分點在當前矩陣在內部就讓這個切分點的cnt+1
            if x > x1[i] and y > y1[i] and x <= x2[i] and y <= y2[i]:
                cnt += 1
        res = max(res,cnt)
print(res)


或者:
import sys
lines = sys.stdin.readlines()
n = int(lines[0])
x1 = list(map(int,lines[1].split()))
y1 = list(map(int,lines[2].split()))
x2 = list(map(int,lines[3].split()))
y2 = list(map(int,lines[4].split()))
 
res = 1
for x in x1+x2:#所有的橫坐標切分點
    for y in y1+y2:#所有的縱坐標切分店
        cnt = 0
        for i in range(n):
            #在所有的橫縱切分點裏面,如果這個切分點在當前矩陣在內部就讓這個切分點的cnt+1
            
#就是下面的判定需要一個是大於等於一個是小於也可以.就是保證矩陣相交點,邊時候不算相交
            if x >= x1[i] and y >= y1[i] and x <x2[i] and y < y2[i]:
                cnt += 1
        res = max(res,cnt)
print(res)
‘‘‘










‘‘‘
[編程題] 牛牛的背包問題
時間限制：1秒
空間限制：32768K
牛牛準備參加學校組織的春遊, 出發前牛牛準備往背包裏裝入一些零食, 牛牛的背包容量為w。
牛牛家裏一共有n袋零食, 第i袋零食體積為v[i]。
牛牛想知道在總體積不超過背包容量的情況下,他一共有多少種零食放法(總體積為0也算一種放法)。

輸入描述:
輸入包括兩行
第一行為兩個正整數n和w(1 <= n <= 30, 1 <= w <= 2 * 10^9),表示零食的數量和背包的容量。
第二行n個正整數v[i](0 <= v[i] <= 10^9),表示每袋零食的體積。


輸出描述:
輸出一個正整數, 表示牛牛一共有多少種零食放法。

輸入例子1:
3 10
1 2 4

輸出例子1:
8

例子說明1:
三種零食總體積小於10,於是每種零食有放入和不放入兩種情況，一共有2*2*2 = 8種情況。



n,w=map(int,input().split())
arr=[int(i)for i in input().split()]

def cnt(arr,w):
    if arr==[]:
        return 1
    if arr[0]<=w:
        tmp=arr[:]
        tmp.pop(0)

        return cnt(tmp,w)+cnt(tmp,w-arr[0])
    if arr[0]>w:
        tmp=arr[:]
        tmp.pop(0)
        return cnt(tmp,w)
if sum(arr)<=m:#這個題目需要用這個公式來加速
    print(2**len(arr))
else:
    print(cnt(arr,w))



別人代碼:寫的逼我簡介,主要是空間消耗逼我的少,看這個改我的上面代碼
line = raw_input()
n = int(line.split(‘ ‘)[0])
w = int(line.split(‘ ‘)[1])
line = raw_input()
v = []
for i in range(n):
    v.append(int(line.strip().split(‘ ‘)[i]))
ans = 0
def main(v, w):
    global ans
    if sum(v) <= w:
        print 2**(len(v))
    else:
        v.sort()
        dfs(0, 0)
        print ans
  
def dfs(su, loc):#看這個是怎麽設計的遞歸函數
#這個函數第一個是目前的重量,第二個是當前在v中的index
    global ans
    if su > w:
        return
    if su <= w:
        ans += 1
    for i in range(loc, n):#表示如果當前重量沒超過w,那麽嗨可以繼續放後面index中的一個.繼續判斷
    #這個遞歸函數寫的,充分避免了數組的使用和數組重復的復制,只用下表就表示了數組的變化
        dfs(su+v[i], i+1)
main(v, w)













‘‘‘





‘‘‘
https://www.nowcoder.com/test/question/32c71b52db52424c89a565e4134bfe4e?pid=6910869&tid=19267265


[編程題] 魔法幣
時間限制：1秒
空間限制：32768K
小易準備去魔法王國采購魔法神器,購買魔法神器需要使用魔法幣,但是小易現在一枚魔法幣都沒有,但是小易有兩臺魔法機器可以通過投入x(x可以為0)個魔法幣產生更多的魔法幣。
魔法機器1:如果投入x個魔法幣,魔法機器會將其變為2x+1個魔法幣
魔法機器2:如果投入x個魔法幣,魔法機器會將其變為2x+2個魔法幣
小易采購魔法神器總共需要n個魔法幣,所以小易只能通過兩臺魔法機器產生恰好n個魔法幣,小易需要你幫他設計一個投入方案使他最後恰好擁有n個魔法幣。 
輸入描述:
輸入包括一行,包括一個正整數n(1 ≤ n ≤ 10^9),表示小易需要的魔法幣數量。


輸出描述:
輸出一個字符串,每個字符表示該次小易選取投入的魔法機器。其中只包含字符‘1‘和‘2‘。

輸入例子1:


輸出例子1:
122

分析知道,第一個機器出來的一定是奇數
第二個機器出來的一定是偶數.所以根據最後需要的硬幣,倒著推即可





a=int(input())
ans=‘‘
while a!=0:
    if a%2==0:
        ans+=‘2‘
        a=(a-2)//2
    else:
        ans+=‘1‘
        a=(a-1)//2
print(ans[::-1])

‘‘‘




‘‘‘
[編程題] 相反數
時間限制：1秒
空間限制：32768K
為了得到一個數的"相反數",我們將這個數的數字順序顛倒,然後再加上原先的數得到"相反數"。例如,為了得到1325的"相反數",首先我們將該數的數字順序顛倒,我們得到5231,之後再加上原先的數,我們得到5231+1325=6556.如果顛倒之後的數字有前綴零,前綴零將會被忽略。例如n = 100, 顛倒之後是1. 
輸入描述:
輸入包括一個整數n,(1 ≤ n ≤ 10^5)


輸出描述:
輸出一個整數,表示n的相反數

輸入例子1:
1325

輸出例子1:
6556




a=int(input())
print(a+int(str(a)[::-1]))

‘‘‘






‘‘‘
[編程題] 字符串碎片
時間限制：1秒
空間限制：32768K
一個由小寫字母組成的字符串可以看成一些同一字母的最大碎片組成的。例如,"aaabbaaac"是由下面碎片組成的:‘aaa‘,‘bb‘,‘c‘。牛牛現在給定一個字符串,請你幫助計算這個字符串的所有碎片的平均長度是多少。

輸入描述:
輸入包括一個字符串s,字符串s的長度length(1 ≤ length ≤ 50),s只含小寫字母(‘a‘-‘z‘)


輸出描述:
輸出一個整數,表示所有碎片的平均長度,四舍五入保留兩位小數。

如樣例所示: s = "aaabbaaac"
所有碎片的平均長度 = (3 + 2 + 3 + 1) / 4 = 2.25

輸入例子1:
aaabbaaac

輸出例子1:
2.25




a=input()
cnt=[]
first=0
for i in range(1,len(a)):
    if a[i]!=a[i-1]:
        cnt.append(i-first)
        first=i
cnt.append(len(a)-first)

print(‘%.2f‘%(sum(cnt)/len(cnt)))







‘‘‘







‘‘‘

https://www.nowcoder.com/question/next?pid=6910869&qid=126950&tid=19267265
[編程題] 遊歷魔法王國
時間限制：1秒
空間限制：32768K
魔法王國一共有n個城市,編號為0~n-1號,n個城市之間的道路連接起來恰好構成一棵樹。
小易現在在0號城市,每次行動小易會從當前所在的城市走到與其相鄰的一個城市,小易最多能行動L次。
如果小易到達過某個城市就視為小易遊歷過這個城市了,小易現在要制定好的旅遊計劃使他能遊歷最多的城市,請你幫他計算一下他最多能遊歷過多少個城市(註意0號城市已經遊歷了,遊歷過的城市不重復計算)。 
輸入描述:
輸入包括兩行,第一行包括兩個正整數n(2 ≤ n ≤ 50)和L(1 ≤ L ≤ 100),表示城市個數和小易能行動的次數。
第二行包括n-1個整數parent[i](0 ≤ parent[i] ≤ i), 對於每個合法的i(0 ≤ i ≤ n - 2),在(i+1)號城市和parent[i]間有一條道路連接。


輸出描述:
輸出一個整數,表示小易最多能遊歷的城市數量。

輸入例子1:
5 2
0 1 2 3

輸出例子1:
3
‘‘‘

為了最後的春招,做牛客網的編程題目