Add files via upload

Author: linwt

2017校招真题编程题汇总/01.合唱团.py

@@ -0,0 +1,15 @@
+# 动态规划
+n = int(raw_input())
+stu = map(int, raw_input().split())
+k, d = map(int, raw_input().split())
+res_max = [[0]*k for _ in range(n)]
+res_min = [[0]*k for _ in range(n)]
+for i in range(n):
+    res_max[i][0] = stu[i]
+    res_min[i][0] = stu[i]
+for j in range(1, k):
+    for i in range(n):
+        for p in range(i+1, min(i+d+1, n)):
+            res_max[p][j] = max(max(res_min[i][j-1]*stu[p], res_max[i][j-1]*stu[p]), res_max[p][j])
+            res_min[p][j] = min(min(res_min[i][j-1]*stu[p], res_max[i][j-1]*stu[p]), res_min[p][j])
+print(max(res_max[i][k-1] for i in range(n)))

2017校招真题编程题汇总/02.地牢逃脱.py

@@ -0,0 +1,47 @@
+'''
+题意可以理解为：有没有可以通行的点，但牛牛到不了（输出-1）。如果没有这样的点，牛牛可能花费最多步数是多少。
+思路：计算地图里，每个点的最短到达步数。找到到不了的点，或者最短步数里步数最多的点。
+1. 创建3个矩阵，size都是n*m的。分别是地图矩阵 mm、步数矩阵 sm、到达矩阵 am。
+2. 设置初始点为第一轮的探索点，更新 sm 里初始点的最短步数为0，更新 am 里初始点的到达状态为1。
+3. 找到从探索点一步能到达的点，且这些点可以通行并没有到达过。更新这些点的 sm 和 am。并将这些点当作下一轮的探索点。
+4. 循环第3步，直到没有新一轮的探索点了。
+5. 从 sm 中可以得到正确答案。
+'''
+
+#coding=utf-8
+n, m = map(int, raw_input().split())
+map_matrix = [raw_input() for _ in range(n)]            # 地图矩阵，'.' 表示可以通行的位置，'X' 表示不可通行的障碍
+x0, y0 = map(int, raw_input().split())                  # 开始点的坐标
+k = int(raw_input())                                    # 共有k种行走方式
+alternative_steps = [map(int, raw_input().split()) for _ in range(k)]  # 可以选择的行走方式
+step_matrix = [[-1]*m for _ in range(n)]                # 步数矩阵，记录到达该点使用最短步数。初始是-1
+arrived_matrix = [[0]*m for _ in range(n)]              # 到达矩阵，记录是否已经到达过该点。初始是0，表示没有到达过
+arrived_matrix[x0][y0] = 1                              # 初始点修改为已到达的点
+step_matrix[x0][y0] = 0                                 # 初始点到达步数为0
+current_points = [[x0, y0]]                             # 第一轮所在的探索点（多个）
+while len(current_points) > 0:                          # 如果当前探索点是0个，结束循环。
+    next_points = []                                    # 下一轮的探索点（多个）
+    for point in current_points:
+        x, y = point[0], point[1]                       # 一个探索点
+        for step in alternative_steps:
+            x_, y_ = x + step[0], y + step[1]           # 该探索点一步能到达的点
+            # 检查是否越界，该点是否可以通行，或者已经达到过
+            if x_ < 0 or x_ >= n or y_ < 0 or y_ >= m or map_matrix[x_][y_] != '.' or arrived_matrix[x_][y_] == 1:
+                continue
+            step_matrix[x_][y_] = step_matrix[x][y] + 1     # 更新步数矩阵
+            arrived_matrix[x_][y_] = 1                      # 更新到达矩阵
+            next_points.append([x_, y_])                    # 该点添加到下一轮探索点里
+    current_points = next_points
+# 从步数矩阵中找到到不了的点，或者最大的步数，然后输出
+try:
+    max_step = 0
+    for i in range(n):
+        for j in range(m):
+            step = step_matrix[i][j]
+            if step==-1 and map_matrix[i][j]=='.':
+                raise Exception
+            if step > max_step:
+                max_step = step
+    print(max_step)
+except:
+    print(-1)

2017校招真题编程题汇总/03.下厨房.py

@@ -0,0 +1,7 @@
+# 每个字符串加到集合中去重
+import sys
+s = set()
+for line in sys.stdin:
+    for i in line.split():
+        s.add(i)
+print(len(s))

2017校招真题编程题汇总/04.分田地.py

@@ -0,0 +1,44 @@
+n,m=map(int,raw_input().strip().split())
+matrix=[map(int,list(raw_input().strip())) for _ in range(n)]
+sum_values = [[0]*(m+1) for i in range(n + 1)]
+for i in range(1, n + 1):
+    for j in range(1, m + 1):
+        sum_values[i][j] += sum_values[i - 1][j] + sum_values[i][j - 1] - sum_values[i - 1][j - 1] + matrix[i-1][j-1]
+
+def calculate_sum(p1,p2):
+    x1,y1=p1
+    x2,y2=p2
+    a1,a2=sum_values[x1 - 1][y1 - 1],sum_values[x1 - 1][y2]
+    a3,a4=sum_values[x2][y1 - 1],sum_values[x2][y2]
+    value=a4-a3-a2+a1
+    return value
+
+def check(mid):
+    for j1 in range(1, m - 2):
+        if calculate_sum((1,1),(n,j1)) < mid * 4: continue
+        for j2 in range(j1 + 1, m - 1):
+            if calculate_sum((1,j1+1),(n,j2)) < mid * 4: continue
+            for j3 in range(j2 + 1, m):
+                if calculate_sum((1,j2+1),(n,j3)) < mid * 4: continue
+                if calculate_sum((1,j3+1),(n,m)) < mid * 4: continue
+                pstart,row_count=1,0
+                for pend in range(1, n + 1):
+                    p1_list=[(pstart,1),(pstart,j1+1),(pstart,j2+1),(pstart,j3+1)]
+                    p2_list=[(pend,j1),(pend,j2),(pend,j3),(pend,m)]
+                    values=[calculate_sum(p1,p2) for p1,p2 in zip(p1_list,p2_list)]
+                    if min(values) >= mid:
+                        pstart=pend+1
+                        row_count+=1
+                        if row_count == 4:return True
+    return False
+
+l, r = 0, sum_values[n][m]
+answer = 0
+while l <= r:
+    mid = (l + r) / 2
+    if check(mid):
+        l = mid + 1
+        answer = mid
+    else:
+        r = mid - 1
+print(answer)

2017校招真题编程题汇总/05.分苹果.py

@@ -0,0 +1,16 @@
+# 可分条件：平均为整数，比平均多的部分可被2整除，且整除结果就是移动次数
+n = int(raw_input())
+s = [int(i) for i in raw_input().split()]
+if sum(s)%len(s)!=0:
+    print(-1)
+else:
+    count = 0
+    avg = sum(s)/len(s)
+    for i in s:
+        if i > avg:
+            if (i-avg)%2==0:
+                count += (i-avg)/2
+            else:
+                count = -1
+                break
+    print(count)

2017校招真题编程题汇总/06.星际穿越.py

@@ -0,0 +1,12 @@
+# 解方程 x*x+x<=h
+# 方法一
+import math
+h = int(raw_input())
+x = int(math.sqrt(h))
+if h-x*x>=x:
+    print(x)
+else:
+    print(x-1)
+
+# 方法二
+print(int(((1+4*input())**0.5-1)/2))

2017校招真题编程题汇总/07.藏宝图.py

@@ -0,0 +1,17 @@
+# 方法一：索引递增
+s, t = raw_input(), raw_input()
+j = flag = 0
+for i in s:
+    if i == t[j]:
+        j += 1
+    if j == len(t):
+        flag = 1
+        break
+print('Yes' if flag else 'No')
+
+# 方法二：字符串截取
+s, t = raw_input(), raw_input()
+for i in s:
+    if t and i == t[0]:
+        t = t[1:]
+print('No' if t else 'Yes')

2017校招真题编程题汇总/08.数列还原.py

@@ -0,0 +1,32 @@
+import itertools
+n, k = map(int, raw_input().split())
+A = map(int, raw_input().split())
+miss_num = []
+miss_index = []
+res = 0
+# 计算序列顺序对个数
+def findCount():
+    count = 0
+    for i in range(len(A)-1):
+        j = i+1
+        while j<len(A):
+            if A[i]<A[j]:
+                count += 1
+            j += 1
+    return count
+# 找出缺失数
+for i in range(1,n+1):
+    if i not in A:
+        miss_num.append(i)
+# 找出缺失数的索引
+for i,v in enumerate(A):
+    if v == 0:
+        miss_index.append(i)
+# 将缺失数进行排列组合
+items = itertools.permutations(miss_num,len(miss_num))
+for item in items:
+    for i,v in enumerate(item):
+        A[miss_index[i]] = v
+    if findCount() == k:
+        res += 1
+print(res)

2017校招真题编程题汇总/09.混合颜料.py

@@ -0,0 +1,26 @@
+# 进行行与行之间的xor，其中1^1=0;  0^0=0;  1^0=1; 0^1=1;
+
+# 矩阵的秩定义：是其行向量或列向量的极大无关组中包含向量的个数。
+# 矩阵的秩求法：用初等行变换化成梯矩阵, 梯矩阵中非零行数就是矩阵的秩
+
+# 问题理解：输入n个数，将这些数之间进行多次xor（异或操作），其中一个数可能被xor多次，看最后能剩余多少不重复的数，输出数量即可。
+# 思路：类似矩阵求秩，首先将各数从大到小排序,对位数与该行相同的进行异或操作
+
+# 具体过程如下：
+#      排序 i=0      异或      排序 i=1    异或      排序 i=2
+# 101010 --> 111010 --> 111010 --> 111010 --> 111010 --> 111010
+# 111010 --> 110110 --> 001100 --> 010111 --> 010111 --> 010111
+# 101101 --> 101101 --> 010111 --> 010000 --> 000111 --> 001100
+# 110110 --> 101010 --> 010000 --> 001100 --> 001100 --> 000111
+
+n = int(raw_input())
+X = map(int, raw_input().split())
+for i in range(n-1,0,-1):
+    X.sort()
+    for j in range(i-1,-1,-1):
+        if X[i]^X[j] < X[j]:
+            X[j] ^= X[i]
+for i in range(n):
+    if X[i]!=0:
+        print (n-i)
+        break

2017校招真题编程题汇总/10.幸运的袋子.py

@@ -0,0 +1,23 @@
+# 递归
+n = int(raw_input())
+x = map(int, raw_input().split())
+x.sort()
+def lucky(x, lsum, lmul):
+    res = 0
+    for i in range(len(x)):
+        if i>0 and x[i]==x[i-1]:
+            continue
+        lsum += x[i]
+        lmul *= x[i]
+        if lsum > lmul:
+            # 符合条件则继续往下扩展一位
+            res = res+1+lucky(x[i+1:], lsum, lmul)
+        elif x[i] == 1:
+            res = res+lucky(x[i+1:], lsum, lmul)
+        else:
+            break
+        # 回溯一位，继续扩展
+        lsum -= x[i]
+        lmul /= x[i]
+    return res
+print(lucky(x, 0, 1))