python题目（10.22）

【PAT A1042】Shuffling Machine

Shuffling is a procedure used to randomize a deck of playing cards. Because standard shuffling techniques are seen as weak, and in order to avoid "inside jobs" where employees collaborate with gamblers by performing inadequate shuffles, many casinos employ automatic shuffling machines. Your task is to simulate a shuffling machine.

The machine shuffles a deck of 54 cards according to a given random order and repeats for a given number of times. It is assumed that the initial status of a card deck is in the following order:

S1, S2, ..., S13, 
H1, H2, ..., H13, 
C1, C2, ..., C13, 
D1, D2, ..., D13, 
J1, J2

where "S" stands for "Spade", "H" for "Heart", "C" for "Club", "D" for "Diamond", and "J" for "Joker". A given order is a permutation of distinct integers in [1, 54]. If the number at the i-th position is j, it means to move the card from position i to position j. For example, suppose we only have 5 cards: S3, H5, C1, D13 and J2. Given a shuffling order {4, 2, 5, 3, 1}, the result will be: J2, H5, D13, S3, C1. If we are to repeat the shuffling again, the result will be: C1, H5, S3, J2, D13.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer K (≤20) which is the number of repeat times. Then the next line contains the given order. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the shuffling results in one line. All the cards are separated by a space, and there must be no extra space at the end of the line.

Sample Input:

2
36 52 37 38 3 39 40 53 54 41 11 12 13 42 43 44 2 4 23 24 25 26 27 6 7 8 48 49 50 51 9 10 14 15 16 5 17 18 19 1 20 21 22 28 29 30 31 32 33 34 35 45 46 47

Sample Output:

S7 C11 C10 C12 S1 H7 H8 H9 D8 D9 S11 S12 S13 D10 D11 D12 S3 S4 S6 S10 H1 

解答： 

k = eval(input())
order = list(map(int,input().split()))
order.insert(0,0)
result_order = [0]*55
result = [None]*55
for i in range(1,55):
    result_order[i] = order[i]
    for j in range(1,k):
        result_order[i] = order[result_order[i]]
for i in range(1,14):
    result[result_order[i]] = "S" + str(i)
for i in range(14,27):
    result[result_order[i]] = "H" + str(i - 13)
for i in range(27,40):
    result[result_order[i]] = "C" + str(i - 26)
for i in range(40,53):
    result[result_order[i]] = "D" + str(i - 39)
result[result_order[53]] = "J1"
result[result_order[54]] = "J2"
result.pop(0)
print(" ".join(result))

 【PAT A1046】Shortest Distance

The task is really simple: given N exits on a highway which forms a simple cycle, you are supposed to tell the shortest distance between any pair of exits.

Input Specification:

Each input file contains one test case. For each case, the first line contains an integer N (in [3,105]), followed by N integer distances D1​ D2​ ⋯ DN​, where Di​ is the distance between the i-th and the (i+1)-st exits, and DN​ is between the N-th and the 1st exits. All the numbers in a line are separated by a space. The second line gives a positive integer M (≤104), with M lines follow, each contains a pair of exit numbers, provided that the exits are numbered from 1 to N. It is guaranteed that the total round trip distance is no more than 107.

Output Specification:

For each test case, print your results in M lines, each contains the shortest distance between the corresponding given pair of exits.

Sample Input:

5 1 2 4 14 9
3
1 3
2 5
4 1

Sample Output:

3
10
7

代码长度限制

16 KB

时间限制

200 ms

内存限制

64 MB

解法一：

按照题目描述：

计算累加a,b之间的数字和之外的数字。但是结果超时。

 开始优化：

1.可以进行一次全加，ab之外的数字可以用Dsum去减而得。

2.python的交换数字直接a,b = b,a

3.sum()内置函数比自己写的循环更快

import sys
NandD = list(map(int,sys.stdin.readline().split()))
M = int(input())
Dsum = sum(NandD[1:])
for i in range(M):
    a,b = map(int,sys.stdin.readline().split())
    if a > b:
        t = b
        b = a
        a = t
    sum1 = sum2 = 0
    for j in range(a,b):
        sum1 += NandD[j]
    sum2 = Dsum - sum1
    print(min(sum1,sum2))

import sys
NandD = list(map(int,sys.stdin.readline().split()))
M = int(input())
Dsum = sum(NandD[1:])
for i in range(M):
    a,b = map(int,sys.stdin.readline().split())
    if a > b:
        a,b = b,a
    sum1 = sum(NandD[a:b])
    sum2 = Dsum - sum1
    print(min(sum1,sum2))

还是超时

方法二：

用空间换时间：

时间大部分浪费在累加上了，想到可以边累加边记录距离，即用二维数组，最后输出直接对应二维数组的角标。

import sys
NandD = list(map(int,sys.stdin.readline().split()))
N = NandD[0]
M = int(input())
Dsum = [[0] * (N+1) for i in range(N+1)]
for i in range(1,N):
    Dsum[i][i+1] = NandD[i]
    for j in range(i+2,N+1):
        Dsum[i][j] = Dsum[i][j-1] + NandD[j-1]
for i in range(M):
    a,b = map(int,sys.stdin.readline().split())
    if a > b:
        a,b = b,a
    sum1 = Dsum[a][b]
    sum2 = Dsum[1][N] + NandD[N] - sum1
    print(min(sum1,sum2))

 内存超限。

但是三角数组的压缩实现太麻烦。实际上这里还是有重复计算。

方法三：

结合方法二，其实可以用一位数组只记录1号节点到其他节点的距离。a,b之间的距离可以通过这个数组计算。

import sys
NandD = list(map(int,sys.stdin.readline().split()))
M = int(input())
dist = [0]*len(NandD)
for d in range(2,len(NandD)):
    dist[d] = dist[d-1] + NandD[d-1]
Dsum = dist[len(NandD)-1] + NandD[-1]
for i in range(M):
    a,b = map(int,sys.stdin.readline().split())
    if a > b:
        a,b = b,a
    sum1 = dist[b] - dist[a]
    sum2 = Dsum - sum1
    print(min(sum1,sum2))