两个总和 - 不起作用

Question

给定一个整数数组，返回两个数字的索引，使它们相加到一个特定的目标。

您可以假设每个输入都只有一个解决方案，并且您不能两次使用相同的元素。 考虑输入 [3,2,4] 和目标是 6。我将 (3,0) 和 (2,1) 添加到地图中，当我到达 4 并将值计算为 6 - 4 作为 2 并且当我检查是否2 是否存在于 map 中的键，它不会进入 if 循环。

我应该得到 [1,2] 的输出，它们分别是 2 和 4 的索引

  public int[] twoSum(int[] nums, int target) {
    int len = nums.length;
    int[] arr = new int[2];
    Map<Integer,Integer> map = new HashMap<Integer,Integer>();
    for(int i = 0;i < len; i++)
    {
        int value = nums[i] - target;
        if(map.containsKey(value))
        {
            System.out.println("Hello");
            arr[0] = value;
            arr[1] = map.get(value);
            return arr;
        }
        else
        {
            map.put(nums[i],i);
        }
    }
    return null;
}

我不知道问题出在哪里，请帮帮我

Answer 1

您应该更新计算值的方式，如下所示：

int value = target - nums[i];

如果您想更好地可视化它，也可以查看this video。它包括蛮力和线性方法：

Answer 2

twoSum 的这段代码可能会对您有所帮助。对于整数数组的输入，如果values之和=target，则返回数组的索引。

public static int[] twoSum(int[] nums, int target) {
     int[] indices = new int[2];
     outerloop:
     for(int i = 0; i < nums.length; i++){
         for(int j = 0; j < nums.length; j++){
             if((nums[i]+nums[j]) == target){
                 indices[0] = i;
                 indices[1] = j;
                 break outerloop;
             }
         }
     }
     return indices;
 }

你可以调用函数使用

 int[] num = {1,2,3};
 int[] out = twoSum(num,4);
 System.out.println(out[0]);
 System.out.println(out[1]);

输出：

0 2

Answer 3

int value = nums[i] - target;

您的减法是倒数，因为nums[i] 可能小于target。所以value 被设置为负数。以下会更好：

int value = target - nums[i];

（修复此问题不会修复您的整个程序，但它解释了为什么您会出现这种行为。）

Answer 4

给定一个整数数组，返回两个数字的索引，使它们相加到一个特定的目标。

您可以假设每个输入都只有一个解决方案，并且您不能两次使用相同的元素。考虑输入 [3,2,4] 和目标是 6。我将 (3,0) 和 (2,1) 添加到地图中，当我到达 4 并将值计算为 6 - 4 作为 2 并且当我检查是否2 是否存在于 map 中的 key，它不会进入 if 循环。

好的，让我们退后一步。

您有一个值列表，[3,2,4]。你需要知道哪两个会加起来6，好吧，通过查看它我们知道答案应该是[1,2]（值2和4）

现在的问题是，你如何以编程方式做到这一点

解决方案是（老实说），非常简单，你需要两个循环，这允许你将列表中的每个元素与列表中的每个其他元素进行比较

for (int outter = 0; outter < values.length; outter++) {
    int outterValue = values[outter];
    for (int inner = 0; inner < values.length; inner++) { 
        if (inner != outter) { // Don't want to compare the same index
            int innerValue = values[inner];
            if (innerValue + outterValue == targetValue) {
                // The outter and inner indices now form the answer
            }
        }
    }
}

虽然效率不高（是的，优化内部循环很容易，但考虑到 OP 当前的尝试，我已经放弃了），这是一个非常简单的示例，说明您如何实现实际上非常常见的问题