从零开始的力扣刷题记录-第十八天

338.比特位计数-简单

题目描述：
给你一个整数 n ，对于 0 <= i <= n 中的每个 i ，计算其二进制表示中 1 的个数 ，返回一个长度为 n + 1 的数组 ans 作为答案。

题解：
O(nlogn)的方案很简单，直接循环遍历计算每一个整数的二进制表示中1的个数。O(n)的方案我一想就是动态规划加位运算，但是一直没有想到一个整数的二进制表示中1的个数和上一个数之间的关系。最后看官方题解有三种做法，感觉还是对位运算不熟悉导致没有想到。

代码（Go）：

func countBits(n int) []int {
    var re = make([]int,n + 1)
    flag := 0
    for i := 0;i <= n;i++{
        j := i
        for j != 0{
            if j%2 == 1{
                flag++
                j = j/2
            }else{
                j = j/2
            }
        }
        re[i] = flag
        flag = 0
    }
    return re
}

509.斐波那契数-简单

题目描述：
斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

题解：
动态规划的标准例子。剩下还有矩阵快速幂和数学方法不常用之前做动态规划时见到过

代码（Go）：

func fib(n int) int {
    if n == 0{
        return 0
    }
    if n == 1{
        return 1
    }
    p := 0;
    q := 1
    for i := 2;i <= n;i++{
        temp := q
        q = p + q
        p = temp
    }
    return q
}

647.最长连续递增序列-简单

题目描述：
给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。
连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。

题解：
这个题其实是之前做过的一个题的弱化版，之前那道题是允许中间断开的情况的，需要动态规划。这个题就可以直接遍历了，用两个变量分别存储最长递增序列和当前递增序列长度就可以了。

代码（Go）：

func findLengthOfLCIS(nums []int) int {
    flag := 1
    temp := 1
    for i := 1;i < len(nums);i++{
        if nums[i] > nums[i - 1]{
            temp++
        }else{
            if temp > flag{
                flag = temp
            }
            temp = 1
        }
    }
    if temp > flag{
        flag = temp
    }
    return flag
}

3.无重复字符的最长子串-中等

题目描述：
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

题解：
算是暴力解的，比暴力解有点优化但不如官方解，看了官方解实际上区别就在于用一个哈希表维护子串中出现的字符，因为我没有用哈希表维护已经出现过的字符，所以每次遍历到新字符都要向前遍历字符串查看有没有重复，官方解实际上是用空间换时间

代码（Go）：

func lengthOfLongestSubstring(s string) int {
    if len(s)  == 0{
        return 0
    }
    flag := 1
    temp := 1
    start := 0
    for i := 1;i < len(s);i++{
        for j := i - 1;j >= start;j--{
            if s[j] == s[i]{
                start = j + 1
                break
            }
            temp++
        }
        if temp > flag{
            flag = temp
        }
        temp = 1
    }
    return flag
}

总结

最后这两道题其实思路差不多，只不过数字大小比较容易比较，而字符是否重复出现需要遍历字符串或者建立哈希表