给定一个整数数组 A，以及一个整数 target 作为目标值，返回满足 i < j < k 且 A[i] + A[j] + A[k] == target 的元组 i, j, k 的数量。
由于结果会非常大，请返回 结果除以 10^9 + 7 的余数。
示例 1：
输入：A = [1,1,2,2,3,3,4,4,5,5], target = 8
输出：20
解释：
按值枚举（A[i]，A[j]，A[k]）：
(1, 2, 5) 出现 8 次；
(1, 3, 4) 出现 8 次；
(2, 2, 4) 出现 2 次；
(2, 3, 3) 出现 2 次。
示例 2：
输入：A = [1,1,2,2,2,2], target = 5
输出：12
解释：
A[i] = 1，A[j] = A[k] = 2 出现 12 次：
我们从 [1,1] 中选择一个 1，有 2 种情况，
从 [2,2,2,2] 中选出两个 2，有 6 种情况。
提示：
3 <= A.length <= 3000
0 <= A[i] <= 100
0 <= target <= 300
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum-with-multiplicity
解题思路
根据题意很容易写出暴力解法----三层循环。
func threeSumMulti(arr []int, target int) int {
result := 0
for i:=0;i<len(arr);i++{
for j:=i+1;j<len(arr);j++{
for k:=j+1;k<len(arr);k++{
if arr[i] + arr[j] + arr[k] == target {
result++
}
}
}
}
return result%(int(math.Pow10(9))+7)
}
很明显，结果就是：
那要怎么优化呢？无非就是减少循环次数嘛！对于多层的循环的优化思路我一直认为可以使用双指针进行优化，但是呢！如果单纯的使用双指针就会发现会有漏的情况，就好比如：1 2 2 2 3 3 4 4 4，目标是5，就只能算出arr[0] + arr[1] + arr[5] ,arr[0] + arr[2] + arr[4]，这两种情况。但是我们可以转化思路，因为对于双指针来说，要么是最左，要么是最右。如果符合了情况，我们可以清楚的计算出符合数字的个数。就好比如：1 2 2 2 3 3 4 4 4，目标是5，我们使用双指针就可以计算出2的个数和3的个数，排列组合结果为2*3=6。但是如果出现：1 6 6 6 6 6 6 6 6 6 6 6，结果为13的情况下，使用的排列组合的公式为：（6的个数*个数减一）/2。
func threeSumMulti(arr []int, target int) int {
result := 0
mod := int(math.Pow10(9))+7
length := len(arr)
sort.Ints(arr)
for i:=0;i<len(arr);i++{
tmp := target - arr[i]
x,y := i+1,len(arr)-1
for x<y {
if arr[x] + arr[y] > tmp {
y--
}else if arr[x] + arr[y] < tmp {
x++
}else if arr[x] + arr[y] == tmp && arr[x]!=arr[y] {
// 这里计算跟arr[x]、arr[y]相等值的个数
left,right := 1,1
tmpx := x
tmpy := y
for tmpx+1<length && arr[tmpx+1] == arr[x] {
tmpx++
left++
}
for tmpy-1 > i && arr[tmpy-1] == arr[y] {
tmpy--
right++
}
log.Println(arr[i],"left:",left, "right:",right)
result += left * right
x = tmpx+1
y = tmpy-1
}else if arr[x] + arr[y] == tmp && arr[x]==arr[y] {
// 这里只要计算出与arr[x]相等的值的个数就可以了
result = result + ((y-x+1)*(y-x))/2
break
}
}
}
return result%mod
}
结果通过，但是还是不太理想，后期继续优化：
