1、Problem1

一、解法

class Solution {
    public int[] twoSum(int[] nums, int target) {
             int maxInNum = Integer.MIN_VALUE;
        int minInNum = Integer.MAX_VALUE;
        for(int i=0; i<nums.length; i++) {
            if (nums[i] > maxInNum) 
                maxInNum = nums[i];
            if (nums[i] < minInNum)
                minInNum = nums[i];
        }
        
        int maxS = target - minInNum;
        int minS = target - maxInNum;
        
        int maxNum = maxS < maxInNum ? maxS : maxInNum;
        int minNum = minS > minInNum ? minS : minInNum;
     
        int[] f = new int[maxNum - minNum + 1];
        
        for (int i=0;i<f.length; i++) {
            f[i] = -1;
        }
        
        for (int i=0; i< nums.length; i++) {
            if (nums[i] <= maxNum && nums[i] >= minNum) {
                if (f[target - nums[i] - minNum] != -1) {
                    return new int[]{f[target -nums[i] - minNum], i};
                } else {
                    f[nums[i] - minNum] = i;
                }
            }
        }
        return null;
    }
}

二、其他解法

摘自
https://segmentfault.com/a/1190000009428229

1、LintCode_56:两数之和等于target

题目大意:给出未排序数组nums和指定目标target,返回数组中两数之和等于target的组合元素下标[index1, index2], 要求下标从1开始,而且index1<index2,保证题目中有且只有1个可行解;

解法1:暴力O(n * n)时间复杂度求解
解题思路:暴力二重循环求解;
复杂度分析:时间复杂度O(n * n),空间复杂度O(1)

/**
 * 解法1:时间复杂度O(n * n),空间复杂度O(1)
 * 遍历求两数之和等于target,返回两数下标(从1开始)
 * http://www.lintcode.com/zh-cn/problem/two-sum/
 * @author yzwall
 */
class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] results = new int[2];
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    results[0] = i + 1;
                    results[1] = j + 1;
                    return results;
                }
            }
        }
        return results;
    }
}

解法2:HashMap O(n)时间复杂度求解
解题思路:耗费O(n)空间构造哈希表,遍历数组每个元素nums[i],哈希表对应存储<target - nums[i], i>,存储nums[i]期望的“另一半”,一旦哈希表中包含nums[i],代表“另一半”早已存储在哈希表中,直接返回即可;
复杂度分析:时间复杂度O(n),空间复杂度O(n)

/**
 * 解法2:HashMap求解,时间复杂度O(n),空间复杂度O(n)
 * 遍历求两数之和等于target,返回两数下标(从1开始)
 * http://www.lintcode.com/zh-cn/problem/two-sum/
 * @author yzwall
 */
class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int[] results = new int[2];
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                results[0] = map.get(nums[i]) + 1;
                results[1] = i + 1;
                break;
            }
            map.put(target - nums[i], i);
        }
        return results;
    }
}

解法3:双指针O(nlog(n))时间复杂度求解
解题思路:首先将数组排序(时间复杂度O(nlog(n))),然后通过双指针i和j分别从数组两头同时遍历,保存数组排序前的元素位置可使用HashMap保存(空间复杂度O(n)),也可用辅助类保存(空间复杂度O(1));
复杂度分析:时间复杂度O(nlog(n)),空间复杂度O(n) or O(1)

/**
 * 解法3:HashMap + 双指针求解,时间复杂度O(nlogn),空间复杂度O(n)
 * 遍历求两数之和等于target,返回两数下标(从1开始)
 * http://www.lintcode.com/zh-cn/problem/two-sum/
 * @author yzwall
 */
class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, ArrayList<Integer>> map = new HashMap<>();
        int[] results = new int[2];
        // HashMap用于记录排序前数组元素对应下标
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(nums[i])) {
                map.get(nums[i]).add(i);
                continue;
            }
            map.put(nums[i], new ArrayList<Integer>());
            map.get(nums[i]).add(i);
        }
        
        int i = 0, j = nums.length - 1;
        // 排序后双指针求解
        Arrays.sort(nums);
        while (i < j) {
            if (nums[i] + nums[j] == target) {
                int index1 = map.get(nums[i]).get(0);
                // 重复元素已经访问过一次,从对应位置列表中剔除
                map.get(nums[i]).remove(0);
                int index2 = map.get(nums[j]).get(0);
                // 保证results[0] < result[1]
                results[0] = Math.min(index1, index2) + 1;
                results[1] = Math.max(index1, index2) + 1;
                return results;
            }
            if (nums[i] + nums[j] > target) {
                j--;
            } else {
                i++;
            }
        }
        return results;
    }
}

2、LintCode_587:两数之和等于target的不重复组合数目

题目大意:给出未排序数组nums和指定目标target,返回数组中两数之和等于target的所有不重复组合数;

解法:双指针法O(n)时间复杂度求解
解题思路:数组排序后使用双指针分别从起点和终点遍历,如果存在a+b=target,则如果找到a所有组合方案,则b无需再找;
复杂度分析:时间复杂度O(nlog(n)),空间复杂度通过HashSet去重,耗费额外空间O(n)(可优化到O(1))

/**
 * 双指针找两数和等于target的不重复组合数目,时间复杂度O(n),空间复杂度O(n)
 * 求两数之和等于target的所有不重复组合数目
 * http://www.lintcode.com/zh-cn/problem/two-sum-unique-pairs/
 * @author yzwall
 */
class Solution {
    public int twoSum6(int[] nums, int target) {
        int pairs = 0;
        if (nums == null || nums.length < 2) {
            return pairs;
        }
        Arrays.sort(nums);
        int i = 0;
        int j = nums.length - 1;
        HashSet<Integer> set = new HashSet<>();
        while (i < j) {
            // 如果a + b = target, a找到后,b无需再找
            while (i < j && set.contains(nums[i])) {
                i++;
            }
            while (i < j && set.contains(nums[j])) {
                j--;
            }
            if (i < j) {
                if (nums[i] + nums[j] == target) {
                    set.add(nums[i]);
                    set.add(nums[j]);
                    pairs++;
                } else if (nums[i] + nums[j] > target) {
                    j--;
                } else {
                    i++;
                }
            }
        }
        return pairs;
    }
}

3、LintCode_608:两数之和等于target(数组已排序)

题目大意:题目是LintCode_56的简化版,解法1和解法2可直接使用;与解法1,2相比,解法3双指针法充分利用数组已排序条件,时间复杂度降低到O(n),空间复杂度降低到O(1)

4、LintCode_443:两数之和大于target

题目大意:求出数组nums中两数之和大于target的组合数目;

解法1:暴力O(n2)时间复杂度求解
二重循环暴力求解;

解法2:双指针法O(nlog(n))时间复杂度求解
解题思路:首先将数组nums升序排序,双指针i从起点开始,指针j从终点开始,一旦有:
nums[i]+nums[j]>target,
则由于数组严格不递减,
∀num∈[nums[i],nums[j]],num+nums[j]>target
,因此执行pairs += (j - i),此时nums[j]所有方案搜索完毕,执行j--;

复杂度分析:时间复杂度O(nlog(n)),空间复杂度O(1)

/**
 * 解法2:双指针法求解,时间复杂度O(logn),空间复杂度O(1) 
 * 求两数之和大于target的组合数目
 * http://www.lintcode.com/en/problem/two-sum-greater-than-target/
 * @author yzwall
 */
class Solution {
     public int twoSum2(int[] nums, int target) {
            int pairs = 0;
            if (nums == null || nums.length < 2) {
                return pairs;
            }
            Arrays.sort(nums);
            int i = 0;
            int j = nums.length - 1;
            while (i < j) {
                if (nums[i] + nums[j] > target) {
                    pairs += j - i;
                    // nums[j]所有方案求解完毕,j--
                    j--;
                } else {
                    i++;
                }
            }
            return pairs;
     }
}

4、LintCode_609:两数之和不超过target

题目大意:求出数组nums中两数之和小于等于target的组合数目;

5、LintCode_610:两数之差等于target

解法1:暴力O(n * n)时间复杂度求解
二重循环暴力求解;

解法2:双指针法O(nlog(n))时间复杂度求解
解题思路:首先将数组nums升序排序,双指针i从起点开始,指针j从终点开始,一旦有:
nums[i]+nums[j]≤target,
则由于数组严格不递减,
∀num∈[nums[i],nums[j]],num+nums[j]≤target
,因此执行pairs += (j - i),此时nums[i]所有方案搜索完毕,执行i++
复杂度分析:时间复杂度O(nlog(n)),空间复杂度O(1)

/**
 * 双指针法求解,时间复杂度O(nlogn),空间复杂度O(1)
 * 求两数之和小于等于target的所有组合数目
 * http://www.lintcode.com/en/problem/two-sum-less-than-or-equal-to-target/
 * @author yzwall
 */
class Solution {
     public int twoSum5(int[] nums, int target) {
        int pairs = 0;
        if (nums == null || nums.length < 2) {
            return pairs;
        }
        Arrays.sort(nums);
        int i = 0;
        int j = nums.length - 1;
        while (i < j) {
            // nums[i]的所有组合 = j - i
            if (nums[i] + nums[j] <= target) {
                pairs += j - i;
                i++;
            } else {
                j--;
            }
        }
        return pairs;
     }
}

6、LintCode_533:两数之和最接近target

题目大意:求出数组nums中两数之和与target的最近距离(非负);

解法1:暴力O(n * n)时间复杂度求解
解题思路:二重循环不断迭代最小距离;
复杂度分析:时间复杂度O(n * n),空间复杂度O(1)

/**
 * 解法1:暴力时间复杂度O(n^2)
 * 求两数之和最接近target,求最近距离
 * http://www.lintcode.com/en/problem/two-sum-closest-to-target/
 * @author yzwall
 */
class Solution {
    public int twoSumClosest(int[] nums, int target) {
        if (nums == null || nums.length < 2) {
            return target;
        }
        
        int min = Integer.MAX_VALUE;
        int temp;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                temp = target - (nums[i] + nums[j]);
                min = Math.min(min, Math.abs(temp));
            }
        }
        return min;
    }
}

解法2:双指针法O(nlog(n))时间复杂度求解
解题思路:首先将数组排序,双指针分别从起点和终点遍历,临时距离
temp=left|target−(nums[i]+nums[j])right|

不停与最短距离min比较迭代,temp=0时直接返回;
复杂度分析:时间复杂度O(nlog(n)),空间复杂度O(1)

/**
 * 解法2:双指针法求解,时间复杂度O(nlogn)
 * 求两数之和最接近target,求最近距离
 * http://www.lintcode.com/en/problem/two-sum-closest-to-target/
 * @author yzwall
 */
class Solution {
    public int twoSumClosest(int[] nums, int target) {
        if (nums == null || nums.length < 2) {
            return target;
        }
        
        Arrays.sort(nums);
        int i = 0;
        int j = nums.length - 1;
        int min = Integer.MAX_VALUE;
        int temp;
        while (i < j) {
            temp = Math.abs(target - (nums[i] + nums[j]));
            if (temp == 0) {
                return 0;
            }
            min = Math.min(min, temp);
            if (nums[i] + nums[j] > target) {
                // 距离过大, j--
                j--;
            } else {
                // 距离过小, i++
                i++;
            }
        }
        return min;
   }
}

7、LintCode_610:两数之差等于target

解法1:暴力O(n * n)时间复杂度求解
二重循环暴力求解;

解法2:双指针法O(nlogn)时间复杂度求解
解题思路:首先将数组nums升序排序,双指针i从起点开始,指针j从终点开始,一旦有:
nums[i]+nums[j]≤target
则由于数组严格不递减,
∀num∈[nums[i],nums[j]],num+nums[j]≤target
,因此执行pairs += (j - i),此时nums[i]所有方案搜索完毕,执行i++
复杂度分析:时间复杂度O(nlog(n)),空间复杂度O(1)

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 141,930评论 1 299
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 60,888评论 1 255
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 93,606评论 0 211
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 40,848评论 0 175
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 48,544评论 1 253
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 38,671评论 1 173
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 30,312评论 2 267
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,112评论 0 165
  • 想象着我的养父在大火中拼命挣扎,窒息,最后皮肤化为焦炭。我心中就已经是抑制不住地欢快,这就叫做以其人之道,还治其人...
    爱写小说的胖达阅读 28,899评论 6 229
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 32,451评论 0 213
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,221评论 2 213
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 30,541评论 1 225
  • 白月光回国,霸总把我这个替身辞退。还一脸阴沉的警告我。[不要出现在思思面前, 不然我有一百种方法让你生不如死。]我...
    爱写小说的胖达阅读 24,196评论 0 31
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,079评论 2 213
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 31,448评论 3 204
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,597评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 25,969评论 0 164
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 33,451评论 2 230
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 33,523评论 2 229

推荐阅读更多精彩内容