my raw answers for leetcode - 1. Two Sum

1. Two Sum

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

 

 

code:

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        vector<int> result;
        int i = 0;

//this variable is used to end up the loop when i get the target two indices, avoid getting the same element twice
        bool ok = false;
        for(;i<nums.size();i++)
        {
            int j = 0;
            for(;j<nums.size();j++)
            {
                int assume_target = nums[i] + nums[j];
                if(assume_target == target)
                {
                    if(i==j)
                    {
                        continue;    
                    }
                    else
                    {
                        result.push_back(i);
                        result.push_back(j);
                        ok = true;//i got them, finish it
                    }
                }
            }
            if(ok){
                break;
            }
        }
        return result;
    }
};

 

 

 

 

comment:

i got 

616 ms

9 MB

Cpp

 

this is bad for the worst-Case Time Complexity in such a simple question.

cuz i have one other loop inside the loop i got Time Complexity of O(n2).

 

For better solution(better Time Complexity), i read some solution from other people. They use hash to store the array with indices and loop once to find the other indice.

 

Then I finish it with this code:

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        vector<int> result;
        map<int, int> the_map;
        for(int i = 0; i<nums.size();i++){
            the_map.insert(map<int,int>::value_type(nums[i],i));
        }
        for(int i = 0; i<nums.size();i++){
            int the_number = target - nums[i];
            if(the_map.count(the_number)>0&&the_map[the_number]!=i){
                result.push_back(i);
                result.push_back(the_map[the_number]);
                break;
            }
        }
        
        return result;
    }
};

 

comment:

Because I want to get the indices, I store the numbers in array as key, and the indices as the value, that I can easily find the indice. 

Attention:

          The Cpp written style  "the_map.insert(map<int,int>::value_type(nums[i],i));"  is not what I'm familiar with. I could be sort of type declaration? It's just like the_map[nums[i]]=i;

 

Finally I got:

4 ms

10.6 MB

Cpp

 

 

There is another way to this solution:

code:

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        vector<int> result;
        map<int, int> the_map;
        for(int i = 0; i<nums.size();i++){
            int the_number = target - nums[i];
            if(the_map.count(the_number)>0){
                result.push_back(i);
                result.push_back(the_map[the_number]);
                break;
            }
            the_map[nums[i]]=i;
        }
        
        return result;
    }
};

 

comment:

I just check if the number I have stored in the hash map is matched to the number I am about to throwing into the map.

This ways seens to be clever but I got worse Time Compexity:

16 ms

10.1 MB

Cpp

 

?

I retried and got:

8 ms

10.1 MB

Cpp

 

I think this is the same as the second solution, milliseconds differece could be random.