力扣算法挑战：简单篇-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_51334054/article/details/119868087

本文介绍了LeetCode上的一些简单算法题目，包括两数之和、获取生成数组的最大值和整数反转。通过对比不同编程语言（Java、C++、Python、C）的解法，强调了哈希表在解决两数之和问题中的应用，以及C++中需要注意的溢出问题。同时还提及了使用DFS解决所有可能路径的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

力扣算法·简单（1）

1.两数之和

第一想到的就是暴力解法了，2重for循环解决

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int i=0,j=1;
        vector<int> result={i,j};
        for(i=0;i<nums.size()-1;i++){
            for(j=i+1;j<nums.size();j++){
                if(nums[i]+nums[j]==target){
                    result={i,j};
                    return result;
                }
            }   
        } 
        return result;
    }
};

发现官方还有更好的方法，是有哈希表做的，学习一哈
java：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            if (hashtable.containsKey(target - nums[i])) {
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

c++：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashtable;
        for (int i = 0; i < nums.size(); ++i) {
            auto it = hashtable.find(target - nums[i]);
            if (it != hashtable.end()) {
                return {it->second, i};
            }
            hashtable[nums[i]] = i;
        }
        return {};
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

python：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target - num], i]
            hashtable[nums[i]] = i
        return []

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

c：

struct hashTable {
    int key;
    int val;
    UT_hash_handle hh;
};

struct hashTable* hashtable;

struct hashTable* find(int ikey) {
    struct hashTable* tmp;
    HASH_FIND_INT(hashtable, &ikey, tmp);
    return tmp;
}

void insert(int ikey, int ival) {
    struct hashTable* it = find(ikey);
    if (it == NULL) {
        struct hashTable* tmp = malloc(sizeof(struct hashTable));
        tmp->key = ikey, tmp->val = ival;
        HASH_ADD_INT(hashtable, key, tmp);
    } else {
        it->val = ival;
    }
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    hashtable = NULL;
    for (int i = 0; i < numsSize; i++) {
        struct hashTable* it = find(target - nums[i]);
        if (it != NULL) {
            int* ret = malloc(sizeof(int) * 2);
            ret[0] = it->val, ret[1] = i;
            *returnSize = 2;
            return ret;
        }
        insert(nums[i], i);
    }
    *returnSize = 0;
    return NULL;
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum/solution/liang-shu-zhi-he-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

发现c确实好麻烦QAQ，不过c的写法也是哈希表底层的实现了，如果能手撸出来有助于提升理解；几门语言的解法全放在这里是为了之后复习的时候顺便复习下几门语言的差异

1646. 获取生成数组中的最大值

今天的每日一题

class Solution {
public:
    int getMaximumGenerated(int n) {
        int nums[n+1];
        int result=1;
        int i=1;
        if(n==0)return 0;
        if(n==1)return 1;
        nums[0]=0;
        nums[1]=1;
        for(i=1;2*i+1<=n;i++){
            nums[2*i]=nums[i];
            nums[2 * i + 1] = nums[i] + nums[i + 1];
            if(result<nums[2*i]) result=nums[2*i];
            if(result<nums[2*i+1]) result=nums[2*i+1];
        }
        return result;   
    }
};

双O(n)的复杂度，不难，官方解法先先提取了公式，感觉无所谓
在这里插入图片描述

7. 整数反转

麻了，第七题就把我干趴下了，主要是范围溢出问题
朴素的错误答案：（当然写完想起来用栈其实更好）

class Solution {
public:
    int reverse(int x) {
        int sign=1;
        int sum=0;
        if(x<0){
            sign=-1;
            x=x*sign;
        }
        if(x==0)return 0;
        while(x%10==0){//后来发现这一步可以省
            x=x/10;
        }
        while(x>10){
            sum+=x%10;
            x=x/10;
            sum*=10;
        }
        sum+=x;
        if(sign==-1)sum*=sign;
        // if(sum<INT_MIN||sum>INT_MAX)return 0;
        // else 
        return sum;
    }
};

这个答案的报错
在这里插入图片描述
果然是溢出问题，本来是想在最后检查是否溢出，但它在红线处就报错了，如果用的java，应该就过了，可惜是c++，其实应该在红线处就得检查是否溢出；怎么检查呢，在推入时检查溢出
但32位环境下需要分析
在这里插入图片描述
关键在上面那个注意
官方解法：

class Solution {
public:
    int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            if (rev < INT_MIN / 10 || rev > INT_MAX / 10) {
                return 0;
            }
            int digit = x % 10;
            x /= 10;
            rev = rev * 10 + digit;
        }
        return rev;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/reverse-integer/solution/zheng-shu-fan-zhuan-by-leetcode-solution-bccn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

思路在官方链接中

797.所有可能的路径

8/25的每日一题，考察dfs，不难，然而好久没碰算法的我已然不会。。。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> stk;
    void dfs(vector<vector<int>>& graph, int x, int n){
         if (x == n) {
            result.push_back(stk);
            return;
        }
        for (auto& y : graph[x]) {
            stk.push_back(y);
            dfs(graph, y, n);
            stk.pop_back();
        }
    }
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        stk.push_back(0);
        dfs(graph,0,graph.size()-1);
        return result;
    }
};