二つの数と
タイトル
整数配列NUMSと目標値の目標を考えると、配列内の2つの整数の目標値を特定し、その配列の添字に戻すように頼みます
あなたは、各入力が一つだけ答えに対応することを想定することができます。ただし、同じ配列要素を再利用することはできません
例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]Javaの：
方法の一つ：暴力行為
暴力は二回マナーNUMSサイクルを通過するだけです
class Solution {
public int[] twoSum(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[j] == target - nums[i]) {
return new int[] { i, j };
}
}
}
throw new IllegalArgumentException("No two sum solution");
}
}複雑性分析：
- 時間の複雑さ：O（N ^ 2）
- 各要素について、我々はそれがO（n）の時間を要するであろう、反復の残りの部分に対応するターゲット要素を見つけようとしています。したがって、時間複雑度はO（N ^ 2）であります
- 宇宙複雑：O（1）
方法2：二回のハッシュテーブル
実行時の複雑さを最適化するために、我々は、アレイ内のターゲット要素かどうかを確認するために、より効率的な方法が必要です。あれば、私たちはそのインデックスを見つける必要があります。に互いに対応し、そのインデックスを持つ配列の各要素を維持するための最良の方法は何ですか？ハッシュテーブル
スピードへの道貿易スペースによって、我々はO（1）にはO（n）から減少した時間を見つけることができます。それはすぐに見つけるために、ほぼ一定の時間をサポートし、この目的のために構築されたハッシュテーブルです。紛争後（n）をOに使用見つけるために時間を変質する可能性があるため、私は、記述するために「近似」を使用しました。しかし、限り、あなたは慎重にハッシュ関数を選択すると、それはでO（1）時間に償却しなければならないハッシュテーブル内で検索します
簡単な実装では、2回の反復を使用しています。最初の反復では、我々は、テーブルに各要素の値とそのインデックスを追加します。次いで、第2の反復において、我々はターゲット要素を検討する（ターゲット - NUMS [i]はターゲットNUMS [i]）と、各要素に対応するテーブル内に存在します。[i]は、それ自体NUMS [i]は、これはターゲット要素のNUMSではないことに注意してください！
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
map.put(nums[i], i);
}
for (int i = 0; i < nums.length; i++) {
int complement = target - nums[i];
if (map.containsKey(complement) && map.get(complement) != i) {
return new int[] { i, map.get(complement) };
}
}
throw new IllegalArgumentException("No two sum solution");
}
}複雑性分析：
- 時間複雑：O（n）は、
- 私たちは二度横断n個の要素のリストが含まれています。ハッシュテーブル時間O（1）を短縮するルックアップので、時間計算量はO（N）であるので
- 宇宙複雑：O（n）は、
- 必要な追加スペースは、ハッシュテーブル内のテーブルにn個の要素を格納された要素の数に依存します
方法3：ハッシュテーブル再び
私たちが完了することができるという事実。そして同時に、テーブルに挿入された繰り返し要素を実行し、我々は戻ってテーブルに対応した目標現在の要素があるかどうかをチェックします。それが存在する場合、我々はに対応する解決策を発見した、とすぐにそれを返します
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums[i];
if (map.containsKey(complement)) {
return new int[] { map.get(complement), i };
}
map.put(nums[i], i);
}
throw new IllegalArgumentException("No two sum solution");
}
}複雑性分析：
- 時間複雑：O（n）は、
- 私たちは、リストが一度n個の要素が含まれているトラバースしなければなりません。各テーブルルックアップで行われるだけでO（1）時間がかかります
- 宇宙複雑：O（n）は、
- 必要な追加スペースがハッシュテーブルに格納された要素の数に依存して、テーブルは、n個の要素まで保存する必要があります
C ++：
方法の一つ：暴力行為
暴力は二回マナーNUMSサイクルを通過するだけです
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
int i,j;
for(i=0;i<nums.size();++i){
for(j=i+1;j<nums.size();++j){
if(nums[i]+nums[j]==target){
return {i,j};
}
}
}
return {i,j};
}
};複雑性分析：
時間の複雑さ：O（N ^ 2）
各要素について、我々はそれがO（n）の時間を要するであろう、反復の残りの部分に対応するターゲット要素を見つけようとしています。したがって、時間複雑度はO（N ^ 2）であります
宇宙複雑：O（1）
方法2：二回ハッシング
マップでは達成する方法は、いずれか一方を提供する連想コンテナSTLは、（第2のキーと呼ばれることがあり、各マップに一度だけ現れることができ、キーワードマップと呼ぶことができるされている最初のものワードの値）データ処理能力
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
map<int,int> a;//建立hash表存放数组元素
vector<int> b(2,-1);//存放结果
for(int i=0;i<nums.size();i++){
a.insert(map<int,int>::value_type(nums[i],i));
}
for(int i=0;i<nums.size();i++){
if(a.count(target-nums[i])>0&&(a[target-nums[i]]!=i)){
//判断是否找到目标元素且目标元素不能是本身
b[0]=i;
b[1]=a[target-nums[i]];
break;
}
}
return b;
};
};複雑性分析：
- 時間複雑：O（n）は、
- 私たちは二度横断n個の要素のリストが含まれています。ハッシュテーブル時間O（1）を短縮するルックアップので、時間計算量はO（N）であるので
- 宇宙複雑：O（n）は、
- 必要な追加スペースは、ハッシュテーブル内のテーブルにn個の要素を格納された要素の数に依存します
方法3：再びハッシング
ハッシュ方式の改善は二回：反復と同時に、テーブルに挿入された要素の間に、我々は戻ってテーブルに対応した目標現在の要素があるかどうかをチェックします。それが存在する場合、我々はに対応する解決策を発見した、とすぐにそれを返します
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
map<int,int> a;//提供一对一的hash
vector<int> b(2,-1);//用来承载结果，初始化一个大小为2，值为-1的容器b
for(int i=0;i<nums.size();i++){
if(a.count(target-nums[i])>0){
b[0]=a[target-nums[i]];
b[1]=i;
break;
}
a[nums[i]]=i;//反过来放入map中，用来获取结果下标
}
return b;
};
};- 時間複雑：O（n）は、
- 私たちは、リストが一度n個の要素が含まれているトラバースしなければなりません。各テーブルルックアップで行われるだけでO（1）時間がかかります
- 宇宙複雑：O（n）は、
- 必要な追加スペースがハッシュテーブルに格納された要素の数に依存して、テーブルは、n個の要素まで保存する必要があります
Pythonの：
方法の一つ：暴力行為
Pythonの関連機能リストで解く
問題解決の主要なキーは、NUM2 =ターゲットを見つけることです- NUM1、リストはまた、あなたは、次の2つのメソッドを使用する必要があるかどうか：NUMSでNUM2、真の指示は私を返される
（NUM2）をnums.index、インデックスNUM2を探します
def twoSum(nums, target):
lens = len(nums)
j=-1
for i in range(lens):
if (target - nums[i]) in nums:
if (nums.count(target - nums[i]) == 1)&(target - nums[i] == nums[i]):#如果num2=num1,且nums中只出现了一次，说明找到是num1本身。
continue
else:
j = nums.index(target - nums[i],i+1)#index(x,i+1)是从num1后的序列后找num2
break
if j>0:
return [i,j]
else:
return []方法2：
行われるが、1636msの合計を長い時間がかかります。
この方法で最適解に基づきます。思考、NUM2は、あなただけの前か後からNUM1位置を探すことができ、再びNUMSからそれぞれを見つけるために見てする必要はありません。しかし、ここでインデックスを容易にするために、以前の位置NUM1から検索]を選択
def twoSum(nums, target):
lens = len(nums)
j=-1
for i in range(1,lens):
temp = nums[:i]
if (target - nums[i]) in temp:
j = temp.index(target - nums[i])
break
if j>=0:
return [j,i]時間のかかる半分以上を、652msの合計を短縮することによって実行されます。
方法3：アナログハッシュ辞書
方法に比べて、このアプローチは、実際には辞書はステップを節約しながら、NUM1とNUM2の値と位置を記録し、その後NUM2インデックスを見つけるされます
def twoSum(nums, target):
hashmap={}
for ind,num in enumerate(nums):
hashmap[num] = ind
for i,num in enumerate(nums):
j = hashmap.get(target - num)
if j is not None and i!=j:
return [i,j]辞書を通って、はるかに高速に効率を探して、大幅に実行速度、88msの合計を減らします。
方法4：
第二の方法と同様にmun2は辞書全体を見つけるに行く必要はありません必要はありません。辞書は、前のNUM1で見つけることができますので、あなただけのサイクルを解決する必要があります
def twoSum(nums, target):
hashmap={}
for i,num in enumerate(nums):
if hashmap.get(target - num) is not None:
return [i,hashmap.get(target - num)]
hashmap[num] = i #这句不能放在if语句之前，解决list中有重复值或target-num=num的情况ハッシュマップ[NUM] =私は＃語句重複値またはターゲットNUM = NUM場合にステートメントが対処する場合は、リストの前に配置することができない
方法に比べていない2メソッド4つの3速度イメージング法の方法が、比較しますスピードブースト。多段速度70msでで