算法刷题记录(LeetCode 631-660)

已于 2023-08-04 12:08:02 修改
阅读量77 收藏
点赞数
分类专栏： 算法 文章标签： 算法 leetcode c#
于 2023-07-15 17:36:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36412089/article/details/131742111
版权

633. Sum of Square Numbers

class Solution {
public:
    inline static double epsilon = 1e-5;
    bool judgeSquareSum(int c) {
        int limit = sqrt(c / 2);
        for (int i = 0; i <= limit; ++i) {
            int residual = c - i*i;
            double res = sqrt(residual);
            if (((double )ceil(res) - res)<epsilon){
                return true;
            }
        }
        return false;
    }
};

637. Average of Levels in Binary Tree

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> currLayer;
        queue<TreeNode*> nextLayer;
        currLayer.push(root);
        vector<double> ans;
        while (!currLayer.empty()){
            double sum=0;
            auto cnt=currLayer.size();
            while (!currLayer.empty()){
                auto curr=currLayer.front();
                currLayer.pop();
                sum+=curr->val;
                if (curr->left){
                    nextLayer.push(curr->left);
                }
                if (curr->right){
                    nextLayer.push(curr->right);
                }
            }
            ans.push_back(sum/cnt);
            currLayer.swap(nextLayer);
        }
        return ans;
    }

640. Solve the Equation

class Solution {
    public static final Set<Character> operators=init_Set();
    public static final String INFINITE_SOLUTIONS="Infinite solutions";
    public static final String NO_SOLUTIONS="No solution";
    public static Set<Character> init_Set(){
        Set<Character> operators=new HashSet<>();
        operators.add('-');
        operators.add('+');
        operators.add('x');
        return operators;
    }
    public String solveEquation(String equation) {
        String[] twoSides=equation.split("=");
        int x_coff=0;
        int constant=0;
        int curr_dire=1;
        char[] left=twoSides[0].toCharArray();
        char[] right=twoSides[1].toCharArray();
        for (int i=0;i<left.length;i++){
            if (left[i]=='+'){
                curr_dire=1;
            }
            else if (left[i]=='-'){
                curr_dire=-1;
            }
            else{
                int j=i;
                while (j<left.length&&!operators.contains(left[j])){
                    j++;
                }
                if (j<left.length&&left[j]=='x'){
                    if (i==j){
                        x_coff+=curr_dire;
                        continue;
                    }
                    x_coff+=curr_dire*Integer.parseInt(twoSides[0].substring(i,j));
                    i=j;
                }
                else{
                    constant+=curr_dire*Integer.parseInt(twoSides[0].substring(i,j));
                    i=j-1;
                }
            }
        }
        curr_dire=-1;
        for (int i=0;i<right.length;i++){
            if (right[i]=='+'){
                curr_dire=-1;
            }
            else if (right[i]=='-'){
                curr_dire=1;
            }
            else{
                int j=i;
                while (j<right.length&&!operators.contains(right[j])){
                    j++;
                }
                if (j<right.length&& right[j]=='x'){
                    if (i==j){
                        x_coff+=curr_dire;
                        continue;
                    }
                    x_coff+=curr_dire*Integer.parseInt(twoSides[1].substring(i,j));
                    i=j;
                }
                else{
                    constant+=curr_dire*Integer.parseInt(twoSides[1].substring(i,j));
                    i=j-1;
                }
            }
        }
        if (x_coff==0){
            if (constant==0){
                return INFINITE_SOLUTIONS;
            }
            return NO_SOLUTIONS;
        }
        return "x="+(-constant/x_coff);
    }

}

641. Design Circular Deque

class MyCircularDeque {
public:
    int capacity = 0;
    vector<int> vec;
    int front = 0;
    int rear = 0;

    MyCircularDeque(int k) {
        capacity = k+1;
        vec.resize(capacity);
    }

    bool insertFront(int value) {
        if (isFull()){
            return false;
        }
        front=(front+capacity-1)%capacity;
        vec[front]=value;
        return true;
    }

    bool insertLast(int value) {
        if (isFull()){
            return false;
        }
        vec[rear]=value;
        rear=(rear+1)%capacity;
        return true;
    }

    bool deleteFront() {
        if (isEmpty()){
            return false;
        }
        front=(front+1)%capacity;
        return true;
    }

    bool deleteLast() {
        if (isEmpty()){
            return false;
        }
        rear=(rear-1+capacity)%capacity;
        return true;
    }

    int getFront() {
        if (isEmpty()){
            return -1;
        }
        return  vec[front];
    }

    int getRear() {
        if (isEmpty()){
            return -1;
        }
        return vec[(rear - 1 + capacity) % capacity];
    }

    bool isEmpty() {
        return front==rear;
    }

    bool isFull() {
        return (rear+1)%capacity==front;
    }
};

643. Maximum Average Subarray I

class Solution {
    public double findMaxAverage(int[] nums, int k) {
        double ans = 0;
        double curr_max = Double.NEGATIVE_INFINITY;
        for (int i = 0; i < k - 1; i++) {
            ans += (double) nums[i] / k;
        }
        int left = 0;
        for (int i = k - 1; i < nums.length; i++) {
            ans += (double) nums[i] / k;
            curr_max = Math.max(curr_max, ans);
            ans -= (double) nums[left] / k;
            left++;
        }
        return curr_max;
    }
}

645. Set Mismatch

    vector<int> findErrorNums(vector<int>& nums) {
        vector<int> ans(2);
        for (int val:nums) {
            int target=abs(val)-1;
            if (nums[target]<0){
                ans[0]=target+1;
            }
            else{
                nums[target]=-nums[target];
            }
        }
        for (int i = 0; i < nums.size(); ++i) {
            if (nums[i]>0){
                ans[1]=i+1;
                return ans;
            }
        }
        return ans;
    }

646. Maximum Length of Pair Chain

贪心 其实就是最多子区间问题

    int findLongestChain(vector<vector<int>>& pairs) {
        std::sort(pairs.begin(), pairs.end(),[](auto a,auto b){
            if (a[1]!=b[1]){
                return a[1]<b[1];
            }
            return a[0]<b[0];
        });
        int curr_end=numeric_limits<int>::min();
        int res=0;
        for (auto & pair : pairs) {
            if (pair[0]>curr_end){
                curr_end=pair[1];
                res++;
            }
        }
        return res;
    }

648. Replace Words

Trie

class Solution {
    public static class PrefixTree {
        boolean end = false;
        HashMap<Character, PrefixTree> children = new HashMap<>();

        public void insert(PrefixTree tree, String _word) {
            char[] word = _word.toCharArray();
            PrefixTree curr = tree;
            for (char s : word) {
                if (!curr.children.containsKey(s)) {
                    curr.children.put(s, new PrefixTree());
                }
                curr = curr.children.get(s);
            }
            curr.end = true;
        }

        public String match(PrefixTree tree, String _word) {
            char[] word = _word.toCharArray();
            StringBuilder path = new StringBuilder();
            PrefixTree curr = tree;
            for (char ch : word) {
                path.append(ch);
                if (!curr.children.containsKey(ch)) {
                    return _word;
                }
                curr = curr.children.get(ch);
                if (curr.end) {
                    return path.toString();
                }
            }
            return _word;
        }
    }

    public String replaceWords(List<String> dictionary, String sentence) {
        PrefixTree tree = new PrefixTree();
        for (String word : dictionary) {
            tree.insert(tree, word);
        }
        StringBuilder res = new StringBuilder();
        String[] words = sentence.split(" ");
        for (String word : words) {
            res.append(tree.match(tree, word)).append(" ");

        }
        return res.toString().strip();
    }
}

650. 2 Keys Keyboard

DP

    int minSteps(int n) {
        int dp[1005];
        dp[0]=0;
        dp[1]=0;
        dp[2]=2;
        for (int i = 3; i <= n; ++i) {
            if (i%2==0) {
                dp[i] = dp[i / 2] + 2;
                continue;
            }
            dp[i]=i;
            for (int j = 3; j < n/2; ++j) {
                if (i%j==0){
                    dp[i]= min(dp[i],dp[j]+i/j);
                }
            }

        }
        return dp[n];
    }

*652. Find Duplicate Subtrees

利用前/中/后序遍历，将为null的节点置入null，判断是否存在相同结构

class Solution {
    public HashMap<String,Integer> alphabet=new HashMap<>();
    public List<TreeNode> res=new ArrayList<>();
    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        dfs(root);
        return res;
    }
    public String dfs(TreeNode root){
        if (root==null){
            return "NULL";
        }
        String s=(root.val+","+dfs(root.left)+","+dfs(root.right));
        if (alphabet.getOrDefault(s,0)==1){
            res.add(root);
        }
        alphabet.put(s,alphabet.getOrDefault(s,0)+1);
        return s;

    }
}

653. Two Sum IV - Input is a BST

class Solution {
public:
    bool findTarget(TreeNode* root, int k) {
        unordered_set<int> require;
        queue<TreeNode*> queue1;
        queue1.push(root);
        while (!queue1.empty()){
            auto curr=queue1.front();
            queue1.pop();
            if(require.count(curr->val)){
                return true;
            }
            else{
                require.insert(k-curr->val);
            }
            if (curr->left){
                queue1.push(curr->left);
            }
            if (curr->right){
                queue1.push(curr->right);
            }
        }
        return false;
    }
};

654. Maximum Binary Tree

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return buildTree(nums,0,nums.length-1);
    }
    public TreeNode buildTree(int[] nums,int start,int end){
        if (start>end){
            return null;
        }
        int maxIdx=getMaxIdx(nums,start,end);
        TreeNode node=new TreeNode(nums[maxIdx]);
        node.left=buildTree(nums,start,maxIdx-1);
        node.right=buildTree(nums,maxIdx+1,end);
        return node;
    }
    public int getMaxIdx(int[] nums,int start,int end){
        if (start>end){
            return -1;
        }
        int max=nums[start];
        int maxIdx=start;
        for (int i=start+1;i<=end;i++){
            if(nums[i]>max){
                maxIdx=i;
                max=nums[i];
            }
        }
        return maxIdx;
    }
}

*655. Print Binary Tree

 struct NodePosition{
    TreeNode *node;
    int idx;

    NodePosition(TreeNode *node, int val) : node(node), idx(val) {}
};
class Solution {
public:
    vector<vector<string>> ans;
    int curr_idx;
    vector<vector<string>> printTree(TreeNode *root) {
        int height = findHeight(root);
        if (height == 0) {
            return ans;
        }
        int length=(int) pow(2,height)-1;
        ans = vector<vector<string>>(height,vector<string>(length,""));
        curr_idx=length/2;
        NodePosition* root_positioned=new NodePosition(root,curr_idx);
        queue<NodePosition*> currNodes;
        queue<NodePosition*> next;
        currNodes.push(root_positioned);
        int curr_layer=0;
        while (!currNodes.empty()){
            while(!currNodes.empty()){
                auto* point=currNodes.front();
                auto * node=point->node;
                currNodes.pop();
                ans[curr_layer][point->idx]= to_string(point->node->val);

                if (node->left){
                    next.push(new NodePosition(node->left,point->idx-(1<<(height-curr_layer-2))));
                }
                if (node->right){
                    next.push(new NodePosition(node->right,point->idx+(1<<(height-curr_layer-2))));
                }
            }
            curr_layer++;
            currNodes.swap(next);
        }
        return ans;
    }

    int findHeight(TreeNode *root) {
        if (root == nullptr) {
            return 0;
        }
        return max(findHeight(root->left), findHeight(root->right)) + 1;
    }
};

657. Robot Return to Origin

    bool judgeCircle(string moves) {
        int cache[2]={0};
        if (moves.length()%2!=0){
            return false;
        }
        for (char ch:moves) {
            switch (ch) {
                case 'L':
                    cache[0]--;
                    continue;
                case 'R':
                    cache[0]++;
                    continue;
                case 'U':
                    cache[1]--;
                    continue;
                case 'D':
                    cache[1]++;
                    continue;
            }
        }
        return cache[0]==0&&cache[1]==0;
    }

658. Find K Closest Elements

    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        if(arr.size()<=k){
            return arr;
        }
        vector<int> ans;
        int left=0;
        int right=arr.size();
        int mid=0;
        while(right-left>1){
            mid=(left+right)>>1;
            if (arr[mid]==x){
                break;
            }
            else if (arr[mid]>x){
                right=mid;
            }
            else{
                left=mid;
            }
        }
        if(arr[mid]==x){
            left=mid,right=mid+1;
        }
        while (k>0){
            if (left<0){
                right++;
                k--;
                continue;
            }
            else if(right==arr.size()){
                left--;
                k--;
                continue;
            }
            int gap_left=abs(arr[left]-x);
            int gap_right=abs(arr[right]-x);
            if(gap_left<=gap_right){
                left--;
            }
            else right++;
            k--;
        }
        //assign实现区间复制
        ans.assign(arr.begin()+left+1,arr.begin()+right);
        return ans;
    }
ほしのした
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题记录---KMP 算法
weixin_43646592的博客
12-18 825
KMP字符串匹配算法
LeetCode刷题记录--- LeetCode 热题 HOT 100
weixin_43646592的博客
12-30 253
🚀 为什么要刷这个专题呢，主要是这个专题其实大部分题都做过了的，想偶尔二刷复习时就刷刷这个专题的题，我想大部分人都是比较不喜欢二刷的，但我认为二刷还不会的题才真的是你的弱项所在，所以刷这个专题的目的就是查漏补缺吧，加油ヾ(◍°∇°◍)ﾉﾞ。
LeetCode刷题-007-整数反转
sinat_21560581的博客
03-02 375
题目地址 https://leetcode-cn.com/problems/reverse-integer/ 解法 不得不说大佬的解法是真的牛逼，我之前是按照记录位数解的，但是太麻烦，最后发现大佬的位数直接是一位一位的进行*10。 代码 class Solution { public int reverse(int x) { long n = 0; while (x != 0) { n = n * 10 + x % 10;
java数据结构与算法刷题-----LeetCode127. 单词接龙
殷志鹏的博客
04-01 1607
【代码】java数据结构与算法刷题-----LeetCode127. 单词接龙。
leetcode刷题记录---454，四数相加Ⅱ
yxlyxlyyy的博客
01-17 458
是一个对容器元素的引用，而不是元素的副本。当在循环中遍历容器时，如果只需要读取元素的值而不修改它，使用引用可以避免不必要的复制，减少了内存的开销和时间消耗。
LeetCode刷题--- 解数独
元清的博客
12-29 1770
数独的解法需遵循如下规则： 数字1-9在每一行只能出现一次。 数字1-9在每一列只能出现一次。 数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用'.'表示。
LeetCode刷题--- 组合总和
元清的博客
12-24 1205
给你一个无重复元素的整数数组candidates和一个目标整数target，找出candidates中可以使数字和为目标数target的 所有不同组合，并以列表形式返回。你可以按任意顺序返回这些组合。 candidates中的同一个数字可以无限制重复被选取。如果至少一个数字的被选数量不同，则两种组合是不同的。 对于给定的输入，保证和为target的不同组合数少于150个。
LeetCode刷题--- 括号生成
元清的博客
12-21 1777
数字n代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。
leetcode刷题----一天一个刷题套路
weixin_43225739的博客
02-18 436
leetcode刷题
leetcode刷题-Day2-数组
smallmaolv的博客
01-12 140
leetcode刷题Day2，#代码随想录
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip
09-15
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip”中，包含的是一个Java编程项目，主要目的是通过代码实践来理解和掌握数据结构、排序算法以及经典的计算机算法。...
leetcode题库-leetcode:leetcode刷题记录
06-29
leetcode算法题 本仓库主要用来保存leetcode算法题代码，主要使用Python/Java编写。 Python代码和Java代码命名风格不一样 用Maven管理依赖，一些用于测试和调试的第三方库依赖 使用IDEA编辑代码
leetcode下载-leetcode-study:leetcode算法刷题
06-29
最近在准备校招暑期实习，算法题必不可少，所以开一个项目，将一些前端必须要掌握的算法题记录下来。 安装 下载项目后，运行： npm install 安装依赖后，运行： npm test 说明 master 分支存放初始项目环境 code ...
leetcode分类-leecode:记录leetcode刷题记录
06-30
本资料集“leetcode分类-leecode:记录leetcode刷题记录”正是针对这一平台，整理出的一套系统的刷题记录，涵盖了各种难度级别的题目，旨在帮助学习者系统化地掌握算法与数据结构知识。 一、刷题分类与难度分级 本...
leetcode分类-leetcode-go:LeetCode刷题记录
06-30
数据结构和算法学习记录，结合LeetCode刷题 分类 DP 目录 题目 解法 分类 Time Space Array O(n) O(n) Linked List O(n) O(1) Sliding Window O(n) O(n) Binary-Search O(log (m+n)) O(1) GO JAVA DP String O(n) O...
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 243
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 263
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 444
糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。/*边界条件:dp[i][j]初始化为负无穷,int dp[1005][1005];//dp[i][j]:从i种糖果中选,组成糖果总数量k的倍数。dp[0][0]=0;//dp[0][0]边界条件:0种糖果组成糖果总数量0的倍数是0。另外,必须保证所有的状态是由dp[0][0]转移过来的*/除了dp[0][0]为0,因为我们这里求的是最大值,
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1073
二叉搜索树向左或向右指明方向，不用遍历整个树。
"详细代码解析：Leetcode刷题记录
在本文中，我将分享我的leetcode刷题记录，包括我在解决每个问题时所使用的代码和思路讲解。这份记录非常详细，旨在帮助其他人更好地理解leetcode题目的解法和编程技巧。 21、TWO SUM 这道题的关键在于要找到数组中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值