update

medium/424.longest-repeating-character-replacement.go

@@ -1,3 +1,51 @@
-func characterReplacement(s string, k int) int {
-	
+type SegmentTree struct {
+	tree []int
+	size int
 }
+
+func newST(n int) SegmentTree {
+	return SegmentTree{
+		tree: make([]int, 2*n),
+		size: n,
+	}
+}
+
+func (st SegmentTree) add(i, val int) {
+	i += st.size
+	st.tree[i] += val
+	for 1 < i {
+		j := i / 2
+		st.tree[j] = maxInt(st.tree[2*j], st.tree[2*j+1])
+		i = j
+	}
+}
+
+func maxInt(x, y int) int {
+	if x < y {
+		return y
+	}
+	return x
+}
+
+func characterReplacement(s string, k int) (max int) {
+	n := len(s)
+	if n-1 <= k {
+		return n
+	}
+	bytes := []byte(s)
+	st := newST(26)
+	fast, slow, cnt := 0, 0, 0
+	for ; fast < n; fast++ {
+		st.add(int(bytes[fast]-'A'), 1)
+		cnt = st.tree[1]
+		for cnt+k < fast-slow+1 {
+			st.add(int(bytes[slow]-'A'), -1)
+			slow++
+			cnt = st.tree[1]
+		}
+		max = maxInt(max, fast-slow+1)
+	}
+	return
+}
+
+

medium/433.minimum-genetic-mutation.go

@@ -0,0 +1,46 @@
+func minMutation(start string, end string, bank []string) int {
+	src, dst := -1, -1
+	for i := range bank {
+		if bank[i] == start {
+			src = i
+		} else if bank[i] == end {
+			dst = i
+		}
+	}
+	if dst == -1 {
+		return -1
+	} else if src == dst {
+		return 0
+	}
+	if src == -1 {
+		bank = append(bank, start)
+		src = len(bank) - 1
+	}
+	n := len(bank)
+	dist := make([]int, n)
+	queue := []int{src}
+	for len(queue) != 0 { // BFS
+		cur := queue[0]
+		queue = queue[1:]
+		for i := 0; i < n; i++ {
+			if i != cur && dist[i] == 0 && isMutable(bank[cur], bank[i]) {
+				dist[i] = dist[cur] + 1
+				queue = append(queue, i)
+			}
+		}
+		if dist[dst] != 0 {
+			return dist[dst]
+		}
+	}
+	return -1
+}
+
+func isMutable(a, b string) bool {
+	cnt := 0
+	for i := range a {
+		if a[i] != b[i] {
+			cnt++
+		}
+	}
+	return cnt == 1
+}

medium/435.non-overlapping-intervals.go

@@ -0,0 +1,29 @@
+/**
+ * Definition for an interval.
+ * type Interval struct {
+ *	   Start int
+ *	   End   int
+ * }
+ */
+func eraseOverlapIntervals(intervals []Interval) (res int) {
+	sort.Sort(inters(intervals))
+	fast, slow, n := 1, 0, len(intervals)
+	for ; fast < n; fast++ { // Greedy
+		if intervals[fast].Start < intervals[slow].End { // If overlaps,
+			if intervals[fast].End < intervals[slow].End { // Choose the interval that ends earlier
+				slow = fast
+			}
+			res++
+		} else {
+			slow = fast
+		}
+	}
+	return
+}
+
+type inters []Interval
+
+func (is inters) Len() int           { return len(is) }
+func (is inters) Less(i, j int) bool { return is[i].Start < is[j].Start }
+func (is inters) Swap(i, j int)      { is[i], is[j] = is[j], is[i] }
+

medium/436.find-right-interval.go

@@ -0,0 +1,10 @@
+/**
+ * Definition for an interval.
+ * type Interval struct {
+ *	   Start int
+ *	   End   int
+ * }
+ */
+func findRightInterval(intervals []Interval) []int {
+	
+}