1031 accepted. 4ms, faster than 60.71%

Author: aQuaYi

Algorithms/1031.maximum-sum-of-two-non-overlapping-subarrays/maximum-sum-of-two-non-overlapping-subarrays.go

@@ -1,6 +1,70 @@
 package problem1031
 
+import "sort"
+
 func maxSumTwoNoOverlap(A []int, L int, M int) int {
+	ls, ms := sums(A, L), sums(A, M)
+	lSize, mSize := len(ls), len(ms)
+	res := 0
+	for i := 0; i < lSize; i++ {
+		if ls[i].sum+ms[0].sum <= res {
+			break
+		}
+		j := 0
+		for j < mSize && ls[i].isOverlapping(ms[j]) {
+			j++
+		}
+		if j < mSize {
+			res = max(res, ls[i].sum+ms[j].sum)
+		}
+	}
+	return res
+}
+
+type entry struct {
+	sum, left, right int
+}
+
+func (e *entry) isOverlapping(other *entry) bool {
+	return max(e.left, other.left) <= min(e.right, other.right)
+}
+
+func sums(A []int, l int) []*entry {
+	n := len(A)
+	res := make([]*entry, n-l+1)
+	sum := 0
+	for i := 0; i < l; i++ {
+		sum += A[i]
+	}
+	for i := l; i < n; i++ {
+		res[i-l] = &entry{
+			sum:   sum,
+			left:  i - l,
+			right: i - 1,
+		}
+		sum += A[i] - A[i-l]
+	}
+	res[n-l] = &entry{
+		sum:   sum,
+		left:  n - l,
+		right: n - 1,
+	}
+	sort.Slice(res, func(i int, j int) bool {
+		return res[i].sum > res[j].sum
+	})
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 
-	return 0
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
 }

Algorithms/1031.maximum-sum-of-two-non-overlapping-subarrays/maximum-sum-of-two-non-overlapping-subarrays_test.go

@@ -1,6 +1,7 @@
 package problem1031
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -14,6 +15,13 @@ var tcs = []struct {
 	ans int
 }{
 
+	{
+		[]int{4, 5, 14, 16, 16, 20, 7, 13, 8, 15},
+		3,
+		5,
+		109,
+	},
+
 	{
 		[]int{0, 6, 5, 2, 2, 5, 1, 9, 4},
 		1,
@@ -53,3 +61,36 @@ func Benchmark_maxSumTwoNoOverlap(b *testing.B) {
 		}
 	}
 }
+
+func Test_sums(t *testing.T) {
+	type args struct {
+		A []int
+		l int
+	}
+	tests := []struct {
+		name string
+		args args
+		want []*entry
+	}{
+		{
+			"test",
+			args{
+				A: []int{0, 1, 2, 3},
+				l: 3,
+			},
+			[]*entry{
+				&entry{6, 1, 3},
+				&entry{3, 0, 2},
+			},
+		},
+
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := sums(tt.args.A, tt.args.l); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("sums() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}