2022年寒假算法练习第四天(1.14)

前言：Golang编写
rank：323725

leetcode

题目：844. 比较含退格的字符串

解法：时间复杂度：O(n)；空间复杂度：1；

逻辑说明：
下面不废话，直接说一下我的思路：
前言：删除数组中的元素用切片的办法删除头元素就是 s[1:] ,前闭后开。

1. 首先，开头的退格符号是得无条件被删除的，因为开头的退格符删除不了任何元素。
2. 假如一个字符后面是退格符#，那么连字符和#都要一起删掉，删完之后，检查一下当前 s[i] 是不是 # 如果是，那么他前面的字符需要删掉，所以 i–，左移到字符的位置，然后下一次循环到这里的时候，就会两者都被删掉了，这里不用担心前面的字符是不是 # ，因为第一个条件里已经把开头多余的#都删掉了，之后的字符肯定不是#。
3. s 串 和t 串 都这样处理一下， 最后进行比较就行了。

func backspaceCompare(s string, t string) bool {
	for i := 0; i < len(s) && i >= 0 && len(s) >= 1; {
		// 去除开头的所有退格 #
		if s[0] == '#' {
			s = s[1:]
			// 去除一个字符后面是 # 的（连字符和 # 一起删除）
		} else if i+1 < len(s) && s[i] != '#' && s[i+1] == '#' {
			s = s[:i] + s[i+2:]
			if len(s) > 0 && i < len(s) && s[i] == '#' && i != 0 {
				i--
			}
		} else {
			i++
		}
	}
	for i := 0; i < len(t) && i >= 0 && len(t) >= 1; {
		if t[0] == '#' {
			t = t[1:]
		} else if i+1 < len(t) && t[i] != '#' && t[i+1] == '#' {
			t = t[:i] + t[i+2:]
			if len(t) > 0 && i < len(t) && t[i] == '#' && i != 0 {
				i--
			}
		} else {
			i++
		}
	}
	return s == t
}

题目：986. 区间列表的交集

解法：时间复杂度：O(n)；空间复杂度：O(1)；

逻辑说明：
先比较firstList的secondList的第一个区间，左边比左边，取大的为left，右边比右边，取小的为right，然后在比较一下left和right，如果确定right比left大，那么就将[]int{left, right}放到ans里面，放完之后，咱在回头看拿一下比较右边界的结果，确定一下到底该比较哪一个数组的下一个区间。

func intervalIntersection(firstList [][]int, secondList [][]int) [][]int {
    var ans [][]int
    i, j := 0, 0
    for i < len(firstList) && j < len(secondList) {
        left, right := 0, 0
        if firstList[i][0] < secondList[j][0] {
            left = secondList[j][0]
        } else {
            left = firstList[i][0]
        }
        if firstList[i][1] < secondList[j][1] {
            right = firstList[i][1]
        } else {
            right = secondList[j][1]
        }
        if left <= right {
            ans = append(ans, []int{left, right})
        }
        if firstList[i][1] < secondList[j][1] {
            i++
        } else {
            j++
        }
    }
    return ans
}

题目：11. 盛最多水的容器
双指针解法：时间复杂度：O(n)；空间复杂度：O(1)；

逻辑说明：刚刚开始做这道题的时候，思路有点偏了，不太清楚后面的指针该怎么走了，后来看题解才发现，只需要比较左右指针所在的数组值大小，谁小移动谁，因为大的不用动，且索引位置的差也就是宽是由大变小的，然后每次ans取宽和高的成绩，然后谁大取谁就可以了。

func maxArea(height []int) int {
    lp, rp := 0, len(height)-1
    ans := 0
    for lp < rp {
        tmp := rp-lp
        if height[lp] < height[rp] {
            tmp *= height[lp]
        } else {
            tmp *= height[rp]
        }
        if ans < tmp {
            ans = tmp
        }
        if height[lp] < height[rp] {
            lp++
        } else {
            rp--
        }
    }
    return ans
}

题目：438. 找到字符串中所有字母异位词

map解法：时间复杂度：O(n)；空间复杂度：O(n)；

逻辑说明：因为题意上说要找异位词，也就是每一个字母的个数是一样的，只不过顺序不同，那么思路就来啦，用map结构存一下每一个小写字母出现的次数，然后遍历s数组，依次取p长度的子串，比较就行。

func findAnagrams(s string, p string) []int {
	var ans []int
	sLen, pLen := len(s), len(p)
	if sLen < pLen {
		return nil
	}
	strMap := make(map[int]int)
	pMap := make(map[int]int)
	for i := 0; i < pLen; i++ {
		strMap[int(s[i])]++
		pMap[int(p[i])]++
	}
	for i := 0; i <= sLen-pLen; i++ {
		flag := true
		for i := 0; i < 26; i++ {
			if strMap['a'+i] != pMap['a'+i] {
				flag = false
				break
			}
		}
		if flag {
			ans = append(ans, i)
		}
		if i < sLen-pLen {
			strMap[int(s[i+pLen])]++
			strMap[int(s[i])]--
		}

	}
	return ans
}

欢迎大家提出更好的建议，如有疑问请评论留言，一般半天就能回复，咱们一起进步。