牛客6

[编程题] 迷宫寻路

时间限制：1秒
空间限制：131072K
假设一个探险家被困在了地底的迷宫之中，要从当前位置开始找到一条通往迷宫出口的路径。迷宫可以用一个二维矩阵组成，有的部分是墙，有的部分是路。迷宫之中有的路上还有门，每扇门都在迷宫的某个地方有与之匹配的钥匙，只有先拿到钥匙才能打开门。请设计一个算法，帮助探险家找到脱困的最短路径。如前所述，迷宫是通过一个二维矩阵表示的，每个元素的值的含义如下 0-墙，1-路，2-探险家的起始位置，3-迷宫的出口，大写字母-门，小写字母-对应大写字母所代表的门的钥匙
输入描述:
迷宫的地图，用二维矩阵表示。第一行是表示矩阵的行数和列数M和N
后面的M行是矩阵的数据，每一行对应与矩阵的一行（中间没有空格）。M和N都不超过100, 门不超过10扇。

输出描述:
路径的长度，是一个整数

输入例子1:
5 5
02111
01a0A
01003
01001
01111

输出例子1:
7

求一下Python正确的答案，这个是根据别人的答案写的，没法AC

#coding=utf-8

class node:
    def __init__(self,x,y,k,step):
        self.x=x
        self.y=y
        self.k=k
        self.step=step

def bfs(startX,startY,arr,Next,N,M,book):
    Q=[]
    Q.append(node(startX,startY,0,0))
    while len(Q)>=0:
        head=Q[0]
        del Q[0]
        if arr[head.x][head.y]=='3':
            return head.step
        for i in range(4):
            nx=head.x+Next[i][0] #上下左右四个方向
            ny=head.y+Next[i][1]
            if nx>=N or nx<0 or ny>=M or ny<0 or arr[nx][ny]=='0':
                continue
            key=head.k
            if arr[nx][ny].islower():
                key=key|(1<<(ord(arr[nx][ny])-ord('a')))
            if arr[nx][ny].isupper() and key&(1<<(ord(arr[nx][ny])-ord('A')))==0:
                continue
            if not book[nx][ny][key]:
                book[nx][ny][key]=1
                Q.append(node(nx,ny,key,head.step+1))
    return 0

while True:
    try:
        s=map(int,raw_input().strip().split())
        M=s[0];N=s[1]
        arr=[]
        for i in range(M):
            arr.append(raw_input().strip())
        Next=[[0,1],[0,-1],[1,0],[-1,0]]
        flag=0
        book=[[[0 for i in range(1024)] for j in range(M)] for j in range(N)]
        for i in range(M):
            if flag==1:
                break
            for j in range(N):
                if arr[i][j]=='2':
                    flag=1
                    book[i][j][0]=1
                    print bfs(i,j,arr,Next,N,M,book)
                    break

    except:
        break

book[x][y][key]的意义就是 横坐标为x,纵坐标为y,钥匙状态为key的点是否访问过
钥匙的状态 就用二进制数表示 最多10 把钥匙 那就是1024
比如我现在有第二把钥匙和第四把钥匙 那么我的钥匙状态就是 0101000000 也就是 320

[编程题] 合唱团

时间限制：1秒
空间限制：32768K
有 n 个学生站成一排，每个学生有一个能力值，牛牛想从这 n 个学生中按照顺序选取 k 名学生，要求相邻两个学生的位置编号的差不超过 d，使得这 k 个学生的能力值的乘积最大，你能返回最大的乘积吗？
输入描述:
每个输入包含 1 个测试用例。每个测试数据的第一行包含一个整数 n (1 <= n <= 50)，表示学生的个数，接下来的一行，包含 n 个整数，按顺序表示每个学生的能力值 ai（-50 <= ai <= 50）。接下来的一行包含两个整数，k 和 d (1 <= k <= 10, 1 <= d <= 50)。

输出描述:
输出一行表示最大的乘积。

输入例子1:
3
7 4 7
2 50

输出例子1:
49

mx记录最大，mn记录最小

#coding=utf-8

while True:
    try:
        n=input()
        a=map(int,raw_input().strip().split())
        ik,d=map(int,raw_input().strip().split())
        if n==1:
            print a[0]
        else:
            mx=[[0 for i in range(n)] for i in range(ik)]
            mn=[[0 for i in range(n)] for i in range(ik)]
            m=0 
            for i in range(n):
                mx[0][i]=mn[0][i]=a[i]
                for k in range(1,ik): 
                    for j in range(i-1,-1,-1): 
                        if i-j>d: 
                            break 
                        mx[k][i]=max(mx[k][i],max(mx[k-1][j]*a[i],mn[k-1][j]*a[i]))
                        mn[k][i]=min(mn[k][i],min(mx[k-1][j]*a[i],mn[k-1][j]*a[i]))
                m=max(m,mx[ik-1][i])
            print m
    except:
        break

[编程题] 下厨房

时间限制：1秒
空间限制：32768K
牛牛想尝试一些新的料理，每个料理需要一些不同的材料，问完成所有的料理需要准备多少种不同的材料。
输入描述:
每个输入包含 1 个测试用例。每个测试用例的第 i 行，表示完成第 i 件料理需要哪些材料，各个材料用空格隔开，输入只包含大写英文字母和空格，输入文件不超过 50 行，每一行不超过 50 个字符。

输出描述:
输出一行一个数字表示完成所有料理需要多少种不同的材料。

输入例子1:
BUTTER FLOUR
HONEY FLOUR EGG

输出例子1:
4

#coding=utf-8

import sys

a=[]
for line in sys.stdin:
    if line.strip()=='':
        break
    a.extend(line.split())
print len(set(a))

[编程题] 分苹果

时间限制：1秒
空间限制：32768K
n 只奶牛坐在一排，每个奶牛拥有 ai 个苹果，现在你要在它们之间转移苹果，使得最后所有奶牛拥有的苹果数都相同，每一次，你只能从一只奶牛身上拿走恰好两个苹果到另一个奶牛上，问最少需要移动多少次可以平分苹果，如果方案不存在输出 -1。
输入描述:
每个输入包含一个测试用例。每个测试用例的第一行包含一个整数 n（1 <= n <= 100），接下来的一行包含 n 个整数 ai（1 <= ai <= 100）。

输出描述:
输出一行表示最少需要移动多少次可以平分苹果，如果方案不存在则输出 -1。

输入例子1:
4
7 15 9 5

输出例子1:
3

自己的有点麻烦

#coding=utf-8

while True:
    try:
        n=input()
        a=map(int,raw_input().strip().split())
        temp=0
        for i in range(1,n):
            if a[i]%2!=a[0]%2:
                temp=1
                break
        if temp==1:
            print -1
        else:
            for i in range(n):
                a[i]/=2
            count=0
            while max(a)!=min(a):
                ma=a.index(max(a));mi=a.index(min(a))
                count+=1
                a[ma]-=1;a[mi]+=1
            print count
    except:
        break

https://www.nowcoder.com/questionTerminal/a174820de48147d489f64103af152709
来源：牛客网
先求出平均数，因为这个数组只可能全是偶数或者全是奇数，所以每个数减去平均数模二取余一定是偶数，只需要算小于平均数的，将差值累加。

while True:
    try:
        flag=True
        n=input()
        a=list(raw_input().split())
        a=[int(i) for i in a]
        if sum(a)%n!=0:
            print -1
        else:
            e=sum(a)/n
            s=0
            for i in a:
                if abs(i-e)%2==1:
                    print -1
                    flag=False
                    break
                if i<e:
                    s+=e-i
            if flag:
                print s/2
    except:
        break

[编程题] 星际穿越

时间限制：1秒
空间限制：32768K
航天飞行器是一项复杂而又精密的仪器，飞行器的损耗主要集中在发射和降落的过程，科学家根据实验数据估计，如果在发射过程中，产生了 x 程度的损耗，那么在降落的过程中就会产生 x2 程度的损耗，如果飞船的总损耗超过了它的耐久度，飞行器就会爆炸坠毁。问一艘耐久度为 h 的飞行器，假设在飞行过程中不产生损耗，那么为了保证其可以安全的到达目的地，只考虑整数解，至多发射过程中可以承受多少程度的损耗？
输入描述:
每个输入包含一个测试用例。每个测试用例包含一行一个整数 h （1 <= h <= 10^18）。

输出描述:
输出一行一个整数表示结果。

输入例子1:
10

输出例子1:
2

如果从1开始循环会超时

#coding=utf-8

import math

while True:
    try:
        n=input()
        x=int(math.sqrt(n))
        while (x+x**2)>n:
            x-=1
        print x
    except:
        break

还可以用(sqrt(1+4*h)-1)/2

[编程题] 藏宝图

时间限制：1秒
空间限制：32768K
牛牛拿到了一个藏宝图，顺着藏宝图的指示，牛牛发现了一个藏宝盒，藏宝盒上有一个机关，机关每次会显示两个字符串 s 和 t，根据古老的传说，牛牛需要每次都回答 t 是否是 s 的子序列。注意，子序列不要求在原字符串中是连续的，例如串 abc，它的子序列就有 {空串, a, b, c, ab, ac, bc, abc} 8 种。
输入描述:
每个输入包含一个测试用例。每个测试用例包含两行长度不超过 10 的不包含空格的可见 ASCII 字符串。

输出描述:
输出一行 “Yes” 或者 “No” 表示结果。

输入例子1:
x.nowcoder.com
ooo

输出例子1:
Yes

#coding=utf-8

import math

while True:
    try:
        s=raw_input().strip()
        t=raw_input().strip()
        temp=0
        for i in t:
            if i in s:
                ind=s.index(i)
                s=s[ind+1:]
            else:
                temp=1
                break
        if temp==0:
            print 'Yes'
        else:
            print 'No'
    except:
        break