9159.com:时间限制,只需要计数

作者: 编程  发布:2019-08-28

LeetCode N-Queens II

LeetCode Unique Binary Search Trees II

总结一下网易2018内推的测试题,我看python的比较少,所以献上自己的low代码,都AC过的,大毛病应该没有,看来基础还是得抓紧练习!

LeetCode Pascal's Triangle II

在N-Queens的基础上计算出共有多少种不同的解法。

9159.com 1

注意点:

只需要计数

例子:

输入: n = 8

输出: 92

LeetCode解题之Unique Binary Search Trees II


[编程题] 彩色的砖块

时间限制:1秒

空间限制:32768K

小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
例如: s = "ABAB",那么小易有六种排列的结果:
"AABB","ABAB","ABBA","BAAB","BABA","BBAA"
其中只有"AABB"和"BBAA"满足最多只有一对不同颜色的相邻砖块。

LeetCode解题之Pascal’s Triangle II


解题思路

思路与 N-Queens 一样,不过把原先用来最后拼装的参数之类都去掉了,换了一个计数器来记录数量。

原题

给定1到n这n个数,用它们能够构成多少种形状不同的二叉搜索树。将所有的二叉搜索树罗列出来。

注意点:

这n个数都要是二叉搜索树的节点,不能只取部分

例子:

输入: n = 3

输出:

   1         3     3      2      1
           /     /      /       
     3     2     1      1   3      2
    /     /                        
   2     1         2                 3
输入描述:
输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s中的每一个字符都为一个大写字母(A到Z)。

原题

用O(k)的空间得到杨辉三角第k行的数值。

注意点:

从0开始计算行数,即第0行为[1]

例子:

输入: k = 3

输出: [1,3,3,1]

[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

AC源码

class Solution(object):
    def totalNQueens(self, n):
        """
        :type n: int
        :rtype: int
        """
        self.col = [False] * n
        self.diag = [False] * (2 * n)
        self.anti_diag = [False] * (2 * n)
        self.result = 0
        self.recursive(0, n)
        return self.result

    def recursive(self, row, n):

        if row == n:
            self.result  = 1
        else:
            for i in range(n):
                if not self.col[i] and not self.diag[row   i] and not self.anti_diag[n - i   row]:
                    self.col[i] = self.diag[row   i] = self.anti_diag[n - i   row] = True
                    self.recursive(row   1, n)
                    self.col[i] = self.diag[row   i] = self.anti_diag[n - i   row] = False


if __name__ == "__main__":
    assert Solution().totalNQueens(8) == 92

 

N-Queens II 在N-Queens的基础上计算出共有多少种不同的解法。 注意点: 只需要计数 例子: 输入: n = 8 输出: 92 解题思路 思路与 N-Quee...

解题思路

Unique Binary Search Trees 只要求不同二叉搜索树的数目,现在要求把所有的树的结构都打印出来。所以在递归的时候要把树拼装出来,而不是仅仅计算数目。而且同一个子树可能会在不同的二叉搜索树中多次出现,为了不重复计算,就用一个map来缓存构造过的树形结构。

输出描述:
输出一个整数,表示小易可以有多少种方式。

解题思路

现在要考虑的是在 Pascal’s Triangle 的基础上节约空间,我们可以知道第k行需要(k 1)的空间,且下一行占用的长度都比上一行长,所以在计算下一行的值时适合从后往前计算。

AC源码

# Definition for a binary tree node.
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution(object):
    def generateTrees(self, n):
        """
        :type n: int
        :rtype: List[TreeNode]
        """
        if n == 0:
            return []
        self.cache = {}
        return self._generateTrees(1, n)

    def _generateTrees(self, start, end):
        if (start, end) not in self.cache:
            roots = []
            for root in range(start, end   1):
                for left in self._generateTrees(start, root - 1):
                    for right in self._generateTrees(root   1, end):
                        node = TreeNode(root)
                        node.left = left
                        node.right = right
                        roots.append(node)
            self.cache[(start, end)] = roots
        return self.cache[(start, end)] or [None]


if __name__ == "__main__":
    None

Unique Binary Search Trees II LeetCode解题之Unique Binary Search Trees II 原题 给定1到n这n个数,用它们能够构成多少种形状不同的二叉搜索树。将...

输入例子1:
ABAB

AC源码

class Solution(object):
    def getRow(self, rowIndex):
        """
        :type rowIndex: int
        :rtype: List[int]
        """
        result = [1] * (rowIndex   1)
        for i in range(2, rowIndex   1):
            for j in range(1, i):
                result[i - j]  = result[i - j - 1]
        return result


if __name__ == "__main__":
    assert Solution().getRow(3) == [1, 3, 3, 1]

Pascal#39;s Triangle II LeetCode解题之Pascals Triangle II 原题 用O(k)的空间得到杨辉三角第k行的数值。 注意点: 从0开始计算行数,即第0行为...

输出例子1:
2
解题思路

麻痹,被题目蒙骗了,别以为是要排列啊,你想一下,两种类型的字母,是不是只有..AAABBB..或者...BBBAAA...这两种情况,三个类型字母特么怎么样都会被接触两次以上!如...AABBCC...

AC代码
a = raw_input("")
new = []
for i in range(len(a)):
    new.append(a[i])
if len(set(new)) == 2:
    print 2
elif len(set(new)) == 1:
    print 1
else:
    print 0

[编程题] 等差数列

时间限制:1秒

空间限制:32768K

如果一个数列S满足对于所有的合法的i,都有S[i 1] = S[i] d, 这里的d也可以是负数和零,我们就称数列S为等差数列。

小易现在有一个长度为n的数列x,小易想把x变为一个等差数列。小易允许在数列上做交换任意两个位置的数值的操作,并且交换操作允许交换多次。但是有些数列通过交换还是不能变成等差数列,小易需要判别一个数列是否能通过交换操作变成等差数列

输入描述:
输入包括两行,第一行包含整数n(2 ≤ n ≤ 50),即数列的长度。
第二行n个元素x[i](0 ≤ x[i] ≤ 1000),即数列中的每个整数。
输出描述:
如果可以变成等差数列输出"Possible",否则输出"Impossible"。
输入例子1:
3
3 1 2
输出例子1:
Possible
解题思路

先排个序,然后后者减去前者做个循环,看看每次减出来的值是不是只有一种,一种就等差

AC代码
a = int(raw_input(""))
b = map(int,raw_input("").split(" "))
c = sorted(b)
res = []
for i in range(len(c)-1):
    res.append(c[i 1]-c[i])
if len(set(res)) == 1:
    print 'Possible'
else:
    print 'Impossible'

[编程题] 交错01串

时间限制:1秒

空间限制:32768K

如果一个01串任意两个相邻位置的字符都是不一样的,我们就叫这个01串为交错01串。例如: "1","10101","0101010"都是交错01串。
小易现在有一个01串s,小易想找出一个最长的连续子串,并且这个子串是一个交错01串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。

输入描述:
输入包括字符串s,s的长度length(1 ≤ length ≤ 50),字符串中只包含'0'和'1'
输出描述:
输出一个整数,表示最长的满足要求的子串长度。
输入例子1:
111101111
输出例子1:
3
解题思路

后者比较前者,如果字符串相同类型,那就重新计数,如果不同类型,且每次都要不同才符合要求,注意最后一点就是考虑一下全值一致的情况,列表为空单独判断

AC代码
a = raw_input("")
max_ = 1
res = []
for i in range(1,len(a)):
    if a[i] != a[i-1]:
        max_  =1
        res.append(max_)
    else:
        max_ = 1

if res == []:
    print 1
else:
    print max(res)

[编程题] 操作序列

时间限制:2秒

空间限制:32768K

小易有一个长度为n的整数序列,a_1,...,a_n。然后考虑在一个空序列b上进行n次以下操作:
1、将a_i放入b序列的末尾
2、逆置b序列
小易需要你计算输出操作n次之后的b序列。

输入描述:
输入包括两行,第一行包括一个整数n(2 ≤ n ≤ 2*10^5),即序列的长度。
第二行包括n个整数a_i(1 ≤ a_i ≤ 10^9),即序列a中的每个整数,以空格分割。
输出描述:
在一行中输出操作n次之后的b序列,以空格分割,行末无空格。
输入例子1:
4
1 2 3 4
输出例子1:
4 2 1 3
解题思路

分治思想,虽然我想的比较low,但是这样编写的时候速度快,分成左右两部分,考虑奇偶情况,写出规律,是一个索引递减的情况,还有需要注意的是,它数是一个个落下来的,不是全部落下来之后再挑选数字再逆序的,所以自己走一下流程,就可以观察到索引的变化

AC代码
n = int(raw_input(""))
a = map(int,raw_input("").split(" "))
b_left = []
b_right = []

# 这一段虽然可行,但是复杂度太高,AC 60%
#for i in a:
#    b.append(i)
#    b.reverse()
#print " ".join(map(str,b))

if len(a)%2 == 0:
    b_left = [a[k] for k in range(len(a)-1,0,-2)]
    b_right = [a[k] for k in range(0,len(a),2)]
else:
    b_left = [a[k] for k in range(len(a)-1,-1,-2)]
    b_right = [a[k] for k in range(1,len(a),2)]

print " ".join(map(str,b_left b_right))

[编程题] 独立的小易

时间限制:1秒

空间限制:32768K

小易为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。一个人生活增加了许多花费: 小易每天必须吃一个水果并且需要每天支付x元的房屋租金。当前小易手中已经有f个水果和d元钱,小易也能去商店购买一些水果,商店每个水果售卖p元。小易为了表现他独立生活的能力,希望能独立生活的时间越长越好,小易希望你来帮他计算一下他最多能独立生活多少天。

输入描述:
输入包括一行,四个整数x, f, d, p(1 ≤ x,f,d,p ≤ 2 * 10^9),以空格分割
输出描述:
输出一个整数, 表示小易最多能独立生活多少天。
输入例子1:
3 5 100 10
输出例子1:
11
解题思路

考虑水果还没吃完就先房租交不起的情况吧,然后就是小学数学,写个方程求解,ok

Dx (D-f)p =d, 反解D就是能活下去的天数

AC代码
x,f,d,p = map(int,raw_input("").split(" "))
if d/x < f:
    print d/x
else:
    print (d f*p)/(x p)

[编程题] 堆棋子

时间限制:1秒

空间限制:32768K

小易将n个棋子摆放在一张无限大的棋盘上。第i个棋子放在第x[i]行y[i]列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有i(1 ≤ i ≤ n)个棋子所需要的最少操作次数.

输入描述:
输入包括三行,第一行一个整数n(1 ≤ n ≤ 50),表示棋子的个数
第二行为n个棋子的横坐标x[i](1 ≤ x[i] ≤ 10^9)
第三行为n个棋子的纵坐标y[i](1 ≤ y[i] ≤ 10^9)
输出描述:
输出n个整数,第i个表示棋盘上有一个格子至少有i个棋子所需要的操作数,以空格分割。行末无空格

如样例所示:
对于1个棋子: 不需要操作
对于2个棋子: 将前两个棋子放在(1, 1)中
对于3个棋子: 将前三个棋子放在(2, 1)中
对于4个棋子: 将所有棋子都放在(3, 1)中
输入例子1:
4
1 2 4 9
1 1 1 1
输出例子1:
0 1 3 10
解题思路

对于一个k,我们找一个坐标(x, y)让k个棋子距离这个坐标的曼哈顿距离之和最小。注意到x和y其实是独立的,考虑枚举棋盘上所有可能得坐标(x[i], y[j]),计算这个坐标到所有棋子的距离分别是多少,然后维护k个棋子对于这个坐标最小曼哈顿距离和即可。—这是抄别人的分析,我自己还在考虑这个问题,他们都用暴力枚举的方法都可行,我得方法中,取了棋子落的上下边界进行遍历,然后有种knn的思想混杂在里面,代码没问题,但是内存超了,后续我再想想

AC 60%,内存超了
n = int(raw_input(""))
x = map(int,raw_input("").split(" "))
y = map(int,raw_input("").split(" "))
gps = zip(x,y)


guess = []
for i in xrange(min(x),max(x) 1):
    for j in xrange(min(y),max(y) 1):
        guess.append((i,j))

result = []
for i in xrange(1,n 1):
    res = []
    for j in guess:
        res.append(sum(sorted(map(lambda x:abs(x[0]-j[0]) abs(x[1]-j[1]),gps))[:i]))
    result.append(min(res))



print " ".join(map(str,result))
AC代码
def ManhattanDistance(x1, y1, x2, y2):
    return abs(x1 - x2)   abs(y1 - y2)

if __name__ == '__main__':
    n = int(input())
    x = [int(i.strip()) for i in raw_input().split(' ')]
    y = [int(i.strip()) for i in raw_input().split(' ')]
    ans = [10 ** 10] * n
    for i in range(n):
        for j in range(n):
            tmp = []
            s = 0
            for k in range(n):
                tmp.append(ManhattanDistance(x[i], y[j], x[k], y[k]))
            tmp.sort()
            for k in range(n):
                s  = tmp[k]
                ans[k] = min(ans[k], s)
    for i in ans:
        print i,

[编程题] 疯狂队列

时间限制:1秒

空间限制:32768K

小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。有一次,n个学生在列队的时候,小易老师正好去卫生间了。学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。由于按照身高顺序排列的队列的疯狂值是最小的,他们当然决定按照疯狂值最大的顺序来进行列队。现在给出n个学生的身高,请计算出这些学生列队的最大可能的疯狂值。小易老师回来一定会气得半死。

输入描述:
输入包括两行,第一行一个整数n(1 ≤ n ≤ 50),表示学生的人数
第二行为n个整数h[i](1 ≤ h[i] ≤ 1000),表示每个学生的身高
输出描述:
输出一个整数,表示n个学生列队可以获得的最大的疯狂值。

如样例所示: 
当队列排列顺序是: 25-10-40-5-25, 身高差绝对值的总和为15 30 35 20=100。
这是最大的疯狂值了。
输入例子1:
5
5 10 25 40 25
输出例子1:
100
解题思路

先排序,挑选中间值,然后左右两边交替换值,重新进一个队列里面。你想象一下,如何使交替的人差值最大,可以考虑对称的思想,最大的最小的,然后和次小的,然后和次大的。。。。

AC代码
n = int(raw_input(""))
line = map(int ,raw_input("").split(" "))
line.sort()
mid = len(line)/2
left = line[0:mid]
right = line[mid 1:]
newline = []

def sumlist(list_):
    res = 0
    for i in range(1,len(list_)):
        res  =abs(list_[i]-list_[i-1])       
    return res

if len(line)%2 == 1:
    while left and right:
        newline.append(right.pop(0))
        newline.append(left.pop())
    newline.append(line[mid])
    print sumlist(newline)

else:
    while left and right:
        newline.append(left.pop())
        newline.append(right.pop(0))
    newline.append(left.pop()) 
    newline.append(line[mid])
    print sumlist(newline)

[编程题] 小易喜欢的数列

时间限制:1秒

空间限制:32768K

小易非常喜欢拥有以下性质的数列:
1、数列的长度为n
2、数列中的每个数都在1到k之间(包括1和k)
3、对于位置相邻的两个数A和B(A在B前),都满足(A <= B)或(A mod B != 0)(满足其一即可)
例如,当n = 4, k = 7
那么{1,7,7,2},它的长度是4,所有数字也在1到7范围内,并且满足第三条性质,所以小易是喜欢这个数列的
但是小易不喜欢{4,4,4,2}这个数列。小易给出n和k,希望你能帮他求出有多少个是他会喜欢的数列。

输入描述:
输入包括两个整数n和k(1 ≤ n ≤ 10, 1 ≤ k ≤ 10^5)
输出描述:
输出一个整数,即满足要求的数列个数,因为答案可能很大,输出对1,000,000,007取模的结果。
输入例子1:
2 2
输出例子1:
3
AC代码
目前,python,我特么AC不出来啊,求助

本文由9159.com发布于编程,转载请注明出处:9159.com:时间限制,只需要计数

关键词: 9159.com

上一篇:没有了
下一篇:没有了