剑指offer之和为S的两个数字

题目描述

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

输出描述

对应每个测试案例，输出两个数，小的先输出。

解题思路

Two pointers的思想

Code

class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        int start = 0, end = array.size()-1;
        long long startMultiplyEnd = -1;
        vector<int> result;
        while(start < end) {
            long long temSum = array[start]+array[end];
            if(temSum == sum) {
                if(startMultiplyEnd == -1) {
                    result.push_back(array[start]);
                    result.push_back(array[end]);
                    startMultiplyEnd = array[start] * array[end];
                } else {
                    long long temp = array[start] * array[end];
                    if(temp < startMultiplyEnd) {
                        result[0] = array[start];
                        result[1] = array[end];
                        startMultiplyEnd = temp;
                    }
                }
                end--;
            } else if(temSum > sum) {
                end--;
            } else {
                start++;
            }
        }
        return result;
    }
};

• java

import java.util.ArrayList;
public class Solution {
    public int binarySearch(int[] array, int target) {
        int left = 0, right = array.length-1;
        while(left <= right) {
            int mid = left+(right-left)/2;
            if(array[mid] == target) {
                return mid;
            } else if(array[mid] > target) {
                right = mid-1;
            } else {
                left = mid+1;
            }
        }
        return -1;
    }
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        for(int i = 0; i < array.length; i++) {
            int target = sum - array[i];
            int pos = binarySearch(array, target);
            if(pos != -1 && pos != i) {
                result.add(array[i]);
                result.add(array[pos]);
                break;
            }
        }
        return result;
    }
}

总结

我的java题解没有考虑数组中有负数、相同元素的情况，鲁棒性比较差，看了评论区的首尾指针（由于相差越远乘积越小）的解法特别棒，学习了

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        int begin = 0, end = array.length-1;
        while(begin < end) {
            int tempsum = array[begin] + array[end];
            if(tempsum > sum) {
                end--;
            } else if(tempsum < sum) {
                begin++;
            } else {
                result.add(array[begin]);
                result.add(array[end]);
                break;
            }
        }
        return result;
    }
}