三道leetcode题&一个带权有向图的ADT的python实现【3.22】

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
我的解法

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        num = digits[0]
        for i in range(len(digits) - 1):
            j = i + 1
            num = num * 10 + digits[j]
        num1 = num + 1
        result = []
        for i in range(len(digits)):
            result.append(num1 % 10)
            num1 = int(num1 / 10)
        if num1==1:
            result.append(1)
        return list(reversed(result))

我的小垃圾解法。。。解了一个小时，但是我还是很开心肿么回事
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
进阶:

如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。
大神解法

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        res=nums[0]
        sum=0
        for i in range(len(nums)):
            if sum>0:
                sum+=nums[i]
            else:
                sum=nums[i]
            res=max(sum,res)
        return res

还有一个

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        max_sum = sum(nums)
        for i in range(len(nums)-1):
        	for j in range(len(nums)-1):
        		max_num=max(max_sum,sum(nums[i:j]))
        return max_num

给定一个仅包含大小写字母和空格 ’ ’ 的字符串，返回其最后一个单词的长度。

如果不存在最后一个单词，请返回 0 。

说明：一个单词是指由字母组成，但不包含任何空格的字符串。

示例:

输入: “Hello World”
输出: 5

import re
class Solution(object):
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        #rt = re.findall('[a-zA-Z]+', s)
        #if rt==[]:
            #return 0
        s=s.strip(" ")
        L=s.split()
        return len(L[-1])

注释了的是我原来的解法，最后发现去除空格就行！！！
今天还改了一个有向图变成带权的。。。

class Node(object):
    def __init__(self, name):
        self.name = name

    @staticmethod
    def get_name(obj):
        if isinstance(obj, Node):
            return obj.name
        elif isinstance(obj, str):
            return obj
        return ''

    def __eq__(self, obj):
        return self.name == self.get_name(obj)

    def __repr__(self):
        return self.name

    def __hash__(self):
        return hash(self.name)

    def __ne__(self, obj):
        return self.name != self.get_name(obj)

    def __lt__(self, obj):
        return self.name < self.get_name(obj)

    def __le__(self, obj):
        return self.name <= self.get_name(obj)

    def __gt__(self, obj):
        return self.name > self.get_name(obj)

    def __ge__(self, obj):
        return self.name >= self.get_name(obj)

    def __bool__(self):
        return self.name

class Weight(object):
    def __init__(self, name):
        self.name = name

    @staticmethod
    def get_name(obj):
        if isinstance(obj, Node):
            return obj.name
        elif isinstance(obj, str):
            return obj
        return ''

    def __eq__(self, obj):
        return self.name == self.get_name(obj)

    def __repr__(self):
        return self.name

    def __hash__(self):
        return hash(self.name)

    def __ne__(self, obj):
        return self.name != self.get_name(obj)

    def __lt__(self, obj):
        return self.name < self.get_name(obj)

    def __le__(self, obj):
        return self.name <= self.get_name(obj)

    def __gt__(self, obj):
        return self.name > self.get_name(obj)

    def __ge__(self, obj):
        return self.name >= self.get_name(obj)

    def __bool__(self):
        return self.name
class DirectedWeightedEdge(object):
    def __init__(self, node_from, node_to,weight):
        self.nf = node_from
        self.nt = node_to
        self.wt = weight
    def __eq__(self, obj):
        if isinstance(obj, DirectedWeightedEdge):
            return obj.nf == self.nf and obj.nt == self.nt and obj.wt == self.wt
        return False

    def __repr__(self):
        return '({0} ->{1} {2})'.format(self.nf, self.nt,self.wt)
class DirectedWeightGraph(object):
    def __init__(self, load_dict={}):
        self.nodes = []
        self.edges = []
        self.weights = []
        self.adjmt = {}
        if load_dict and type(load_dict) == dict:
            for v,method in load_dict.items():
                node_from = self.add_node(v)
                self.adjmt[node_from]={}
                for w,n in method.items():
                    node_to = self.add_node(n)
                    weight = self.add_weight(w)
                    self.adjmt[node_from][weight]=node_to
                    self.add_edge(v,n,w)

                # self.adjmt[node_from][method] = []
                # for w in self.adjmt[node_from].values():
                #     for n in self.adjmt[node_from].values():
                #         node_to = self.add_node(n)
                #         self.adjmt[node_from].append(node_to)
                #         self.add_edge(v, n, k)

    def add_node(self, node_name):
        try:
            return self.nodes[self.nodes.index(node_name)]
        except ValueError:
            node = Node(node_name)
            self.nodes.append(node)
            return node
    def add_weight(self, weight_name):
        try:
            return self.weights[self.weights.index(weight_name)]
        except ValueError:
            weight = Weight(weight_name)
            self.weights.append(weight)
            return weight
    def add_edge(self, node_name_from, node_name_to,weight):
        try:
            node_from = self.nodes[self.nodes.index(node_name_from)]
            node_to = self.nodes[self.nodes.index(node_name_to)]
            edge_weight = self.weights[self.weights.index(weight)]
            self.edges.append(DirectedWeightedEdge(node_from, node_to,edge_weight))
        except ValueError:
            pass
if __name__ == '__main__':
    g=DirectedWeightGraph({'LoginPage':{
                                            'login':'HomePage',
                                            'other':'ErrorPage',
                                        },
                            'HomePage':{
                                            'goto_user':'UserPage',
                                            'goto_good':'GoodPage',
                            }

    })
    print(g.edges)

字典套字典吧，还要学习的好多