zoukankan      html  css  js  c++  java
  • leetcode_1. Two Sum

    leetcode_1. Two Sum

    前言:

    这段时间开始敲leetcode。我认为这并不仅仅只是为了应付笔试,面试。而是确实有着一定的意义。

    尤其,你提交代码后,网站会多方面验证你的答案。

    另外,提交成功后,你可以查看自己的运行时间,以及别人的运行时间。

    最最关键的是,这之后,你可以查看别人的优秀代码。

    这还不算,其中讨论模块,解决方案模块。

    虽然以前在大学,玩过ACM。但是,体验和leetcode差很多。

    所以,我是比较推荐的。

     

    之前,我都是按照题目的序号来进行解题。

    不过,其中hard难度的题目,确实对于现在的我来说有一定难度。

    尤其是做到一篇寻找最长回文串的midium难度后,又做了一个判断是否为回文串的easy难度题目。

     

    所以,我决定从简单的题目开始做起来。

    我应该只会将一些midium难度的题目发布上来。以及一些有着不错亮点的easy题目。

     

     

    一,问题:

    Given an array of integers, return indices of the two numbers such that they add up to a specific target.

    You may assume that each input would have exactly one solution, and you may not use the same element twice.

    Example:

    Given nums = [2, 7, 11, 15], target = 9,
    
    Because nums[0] + nums[1] = 2 + 7 = 9,
    return [0, 1].

    翻译:

    函数的输入是一个int数组以及一个目标值。通过在数组中选择两个int整数,来凑出目标值。

    我们可以假设每个输入只有一个解决方案。并且数组中的每个元素只能使用一次。

    (貌似,现在已经有了leetcode中文版。但是一方面,我希望锻炼一下自己的专业英文,另一方面,中文版的功能支持还不完善)

    二,思路:

    1.暴力法:通过双重循环,来遍历所有可能性,判断是否与目标值相等,如果相等,输入该循环内的两个数。

      优化:类比于排序算法的优化,外层循环遍历的nums[i]与内层循环遍历的nums[j],完全没必要再通过外层循环的nums[j]与内层循环的nums[i]这样来重复。

    2.针对法:通过单次循环获取数组中每一个元素nums[i],再通过找寻数组内是否存在nums[j]使得nums[j]==target-nums[i],因为许多语言,内置了相关的搜搜索函数。如js的indexof.

    三,代码:

    我之后的这些题目都将采用go语言来实现。

    V1:

    func twoSum(nums []int, target int) []int {
        result := make([]int, 0)
        for k, v := range nums {
            for k2, v2 := range nums[k+1:] {
                if v+v2 == target {
                    result = append(result, k,k2+k+1)
                    return result
                }
            }
        }
        return result
    }

    由于并没有在go中找到相关的类似indexof的函数,所以,我便采用了暴力解法。

    Runtime:80ms,6.40%

    这里,我对于go的slice产生了一些疑惑,这导致我增添了一个无用的result变量。所以,我需要修改一下。

    V2:

    func twoSum(nums []int, target int) []int {
        for k, v := range nums {
            for k2, v2 := range nums[k+1:] {
                if v+v2 == target {
                    return []int{k, k+k2+1}
                }
            }
        }
        return []int{}
    }

    PS:我们完全可以通过一句    return []int{k, k+k2+1}  来新建并返回一个匿名的slice。

    Runtime:36ms,39.93%

    相对与V1版本有了进步,但是仍然与TOP1的差很多。

    从语法的角度,改进的空间已经不是很大了。那么只能从算法的结构上来提升。

    虽然,go语言没有indexof。但是go语言还有map。

    我曾今见过一两个通过map来提升速度的函数。但是,轮到自己来设计,还真是有些不适应。尤其,我对map还不是那么的熟悉,这导致我无法了解它的原理,从而降低耗时。

    所以,我只能先试一试。直接先将所有的值都放在Map上,然后通过map间接性的实现indexof功能。

    V3:

    func twoSum(nums []int,target int) []int {
        m:=make(map[int]int)
        for k,v:=range nums{
            m[v]=k
        }
        for k,v:=range nums{
            another:=target-v
            k2,ok:=m[another]
            if ok== true &&k!=k2{
                return []int{k,k2}
            }
        }
        return nil
    }

    PS:这算是最无脑,直接的map算法。

    Runtime:32ms,40.19%

    即使这个算法非常无脑,只是非常僵硬地使用了map。但是依旧比v2快速。并且,这个方法从代码的角度依旧可以改进嘛。

    起码两次循环遍历,完全是可以避免的。

    V4:

     1 func twoSum(nums []int,target int) []int {
     2     m:=make(map[int]int)
     3     for k,v:=range nums{
     4         another:=target-v
     5         k2,ok:=m[another]
     6         if ok== true &&k!=k2{
     7             return []int{k,k2}
     8         }
     9         m[v]=k
    10     }
    11     return nil
    12 }

    PS:这里有一个非常关键的地方,那就是第9行的m[v]=k必须在第5行的k2,ok:=m[another]前。这样就避免了数组内有相同元素3,target=6,而导致的k2=k的情况。因为在map中相同键值的value值会后者覆盖前者的。

    Runtime:8ms,85.92%

    这可以说是一个非常喜人的结果了。从最后的结果分析图来看,只有一种算法要超过V4算法。

    但是,我在尝试了几次代码上map的优化,还是没有办法。我甚至想是不是从内存的角度解决的。但是感觉可能性不大。

    最后,简化出一个版本。

    V5:

     1 func twoSum(nums []int,target int) []int {
     2     m:=make(map[int]int)
     3     for k,v:=range nums{
     4         another:=target-v
     5         if k2,ok:=m[another]; ok {
     6             return []int{k,k2}
     7         }
     8         m[v]=k
     9     }
    10     return nil
    11 }

    Runtime:8ms,85.92%

    虽然,简化了内存和判断条件。但是运算时间依然没有提高。甚至在一次改进中还出现时间增加到12ms的情况。

    所以这应该是我提交的最终版本了。

    四,他人代码:
    1.最佳代码:

    无论如何,也要看看完成最佳的代码是如何实现的。

     1 func twoSum(nums []int, target int) []int {
     2     m := make(map[int]int)
     3     for i := 0; i < len(nums); i++ {
     4         comp := target - nums[i]
     5         if _, ok := m[comp]; ok {
     6             return []int {m[comp], i}
     7         }
     8         m[nums[i]] = i
     9     }
    10     return nil
    11 }

    Runtime:4ms,100%

    2.分析:

    从这个代码来看,其结构基本和我的最终版V5类似了。区别在于1,他没有使用range函数;2,他第5行没有接受key值,在第6行中采用map[key]来获取所需的value值。

    那么究竟是哪个造成这4ms的差距。

    但从理论上分析,我确实无法做到。但是我可以一个个去尝试嘛。

    3.结果:

    然而,在测试过程中,我发现了很尴尬的情况。那就是我的V5算法和TOP算法会跳动。有时候4ms,100%,有时候8ms,85.92%。

    结果,另外一次提交:

    请注意,下面的代码部分是完全一摸一样的。。。

    表示这种情况也是有些尴尬。

    不过,两者的算法应该差距不大了。

    五,总结:

    1,任何问题的第一要求是解决问题。不管是什么方法,想想出来一个解决问题。再谈优化。

    2.任何函数都需要各种各样的测试,如溢出等。这样才可以令函数更具健壮性。

    3.很多时候,go可以通过map来实现其他语言indexof的功能。而且性能很好。

    4.算法结构解决完了,更可以优化代码结构。

    PS:V4中解决键值冲突,只需要简单的换个位置就可以了。

    PS2:map通过键值找不到的值,会返回相关零值。如果需要判断到底是否存在,请使用ok接收。

    如有更正,请指出。谢谢。

    (话说,for循环中到底是用i好呢,还是用range更好呢。)

  • 相关阅读:
    今日SGU 5.27
    今日SGU 5.26
    今日SGU 5.25
    软件工程总结作业
    个人作业——软件产品案例分析
    个人技术博客(α)
    结对作业二
    软工实践 二
    软工实践 一
    《面向对象程序设计》六 GUI
  • 原文地址:https://www.cnblogs.com/Tiancheng-Duan/p/9035580.html
Copyright © 2011-2022 走看看