LeetCode究极班系列(36-40)

最新推荐文章于 2023-01-02 10:24:14 发布
最新推荐文章于 2023-01-02 10:24:14 发布
阅读量247 收藏
点赞数 1
分类专栏： 算法题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44173974/article/details/109121327
版权

36. 有效的数独

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

输入:
[
[“5”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”]
]
输出: true

输入:
[
[“8”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”]
]
输出: false
解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。
但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。

说明:
一个有效的数独（部分已被填充）不一定是可解的。
只需要根据以上规则，验证已经填入的数字是否有效即可。
给定数独序列只包含数字 1-9 和字符 ‘.’ 。
给定数独永远是 9x9 形式的。

算法描述

按照有效性的定义直接模拟就好了

模拟

class Solution {
public:
    bool st[9]; 
    bool isValidSudoku(vector<vector<char>>& board) {
        for(int i=0;i<9;i++){
            memset(st,0,sizeof st);
            for(int j=0;j<9;j++){
                if(board[i][j]!='.'){
                    int t=board[i][j]-'1';
                    if(st[t]) return false;
                    st[t]=true;
                }
            }
        }

        for(int i=0;i<9;i++){
            memset(st,0,sizeof st);
            for(int j=0;j<9;j++){
                if(board[j][i]!='.'){
                    int t=board[j][i]-'1';
                    if(st[t]) return false;
                    st[t]=true;
                }
            }
        }

        for(int i=0;i<9;i+=3){
            for(int j=0;j<9;j+=3){
                memset(st,0,sizeof st);
                for(int x=0;x<3;x++){
                    for(int y=0;y<3;y++){
                        if(board[i+x][j+y]!='.'){
                            int t=board[i+x][j+y]-'1';
                            if(st[t]) return false;
                            st[t]=true;
                        }
                    }
                }
            }
        }
        return true;


    }
};

37. 解数独

编写一个程序，通过填充空格来解决数独问题。
一个数独的解法需遵循如下规则：
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
空白格用 ‘.’ 表示。

在这里插入图片描述
在这里插入图片描述

提示：
给定的数独序列只包含数字 1-9 和字符 ‘.’ 。
你可以假设给定的数独只有唯一解。
给定数独永远是 9x9 形式的。

算法描述

开三个数组表示行列以及小方格内的9个元素是否被使用
然后枚举空格的所有可能性 直接回溯

暴力回溯

class Solution {
public:
    bool row[9][9],col[9][9],cell[3][3][9];
    void solveSudoku(vector<vector<char>>& board) {
        memset(row,0,sizeof row);
        memset(col,0,sizeof col);
        memset(cell,0,sizeof cell);


        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++){
                if(board[i][j]!='.'){
                    int t=board[i][j]-'1';
                    row[i][t]=col[j][t]=cell[i/3][j/3][t]=true;
                }
            }

        dfs(board,0,0);
    }

    bool dfs(vector<vector<char>>& board,int x,int y){
        if(y==9) x++,y=0;
        if(x==9) return true;

        if(board[x][y]!='.') return dfs(board,x,y+1);
        for(int i=0;i<9;i++){
            if(!row[x][i] && !col[y][i] && !cell[x/3][y/3][i]){
                board[x][y]=i+'1';
                row[x][i]=col[y][i]=cell[x/3][y/3][i]=true;
                if(dfs(board,x,y+1)) return true;
                board[x][y]='.';
                 row[x][i]=col[y][i]=cell[x/3][y/3][i]=false;
            }
        }
        return false;

    }
};

38. 外观数列

给定一个正整数 n（1 ≤ n ≤ 30），输出外观数列的第 n 项。
注意：整数序列中的每一项将表示为一个字符串。
「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。前五项如下：

  1. 1

  2. 11

  3. 21

  4. 1211

  5. 111221

第一项是数字 1
描述前一项，这个数是 1 即 “一个 1 ”，记作 11
描述前一项，这个数是 11 即 “两个 1 ” ，记作 21
描述前一项，这个数是 21 即 “一个 2 一个 1 ” ，记作 1211
描述前一项，这个数是 1211 即 “一个 1 一个 2 两个 1 ” ，记作 111221

输入: 4
输出: “1211”
解释：当 n = 3 时，序列是 “21”，其中我们有 “2” 和 “1” 两组，“2” 可以读作 “12”，也就是出现频次 = 1 而 值 = 2；类似 “1” 可以读作 “11”。所以答案是 “12” 和 “11” 组合在一起，也就是 “1211”。

算法描述

每一次的字符串都是对上一次字符串的计算得出的 统计每个字符的个数 然后加到当前字符串里面

双指针

class Solution {
public:
    string countAndSay(int n) {
        string s="1";
        for(int i=0;i<n-1;i++){
            string t;
            for(int j=0;j<s.size();){
                int k=j+1;
                while(k<s.size() && s[k]==s[j]) k++;
                t+=to_string(k-j)+s[j];
                j=k;
            }
            s=t;
        }
        return s;
    }
};

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
说明：
所有数字（包括 target）都是正整数。
解集不能包含重复的组合。

输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
[7],
[2,2,3]
]

算法描述

回溯法的典型应用场景

dfs(朴素思想)

class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<int> path;
        dfs(candidates,path,target,0);
        return res;
    }
    void dfs(vector<int>& a,vector<int>& path,int target,int idx){
        if(target==0){
            res.push_back(path);
            return;
        }
        for(int i=idx;i<a.size();i++){
            if(target<a[i]) continue;
            path.push_back(a[i]);
            dfs(a,path,target-a[i],i);
            path.pop_back();
        }    
    }
};

dfs(多重背包思想)

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> combinationSum(vector<int>& c, int target) {
        dfs(c,0,target);
        return res;
    }
    void dfs(vector<int>& c,int u,int target){ //u是当前枚举到第几个数了
        if(target==0){
            res.push_back(path);
            return;
        }
        if(u==c.size()) return;
        for(int i=0;c[u]*i<=target;i++){
            dfs(c,u+1,target-c[u]*i);
            path.push_back(c[u]);//因为是u选0个开始的 所以后面再push_back
        }
        for(int i=0;c[u]*i<=target;i++){
            path.pop_back();
        }
    }
};

40. 组合总和 II

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
说明：
所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]

算法描述

照搬上一题了 就加了排序和暴力去重

暴力dfs

class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        vector<int> path;
        dfs(candidates,path,target,0);
        return res;
    }
    void dfs(vector<int>& a,vector<int>& path,int target,int idx){
        if(target<=0){
            if(target==0 && count(res.begin(),res.end(),path)==0) res.push_back(path);
            return;
        }
        for(int i=idx;i<a.size();i++){
            path.push_back(a[i]);
            dfs(a,path,target-a[i],i+1);
            path.pop_back();
        }    
    }
};

算发描述

相比于上面一个用find函数暴力查找的方法 这个使用了一个布尔数组和一句判断解决去重
我们看这句代码 if(i>0 && a[i]==a[i-1] && !st[i-1]) continue; 字面意思就是当前元素和上一个元素相同 并且上一个元素未被使用 就跳过 原理来自于逻辑推导或者是搜索树的剪枝

优化dfs

class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> st(candidates.size());
        vector<int> path;
        sort(candidates.begin(),candidates.end());
        dfs(st,candidates,path,target,0);
        return res;
    }
    void dfs(vector<bool>& st,vector<int>& a,vector<int>& path,int target,int idx){
        if(target==0){
            res.push_back(path);
            return;
        }
        for(int i=idx;i<a.size();i++){
            if(st[i] || target<a[i]) continue;
            if(i>0 && a[i]==a[i-1] && !st[i-1]) continue;
            path.push_back(a[i]);
            st[i]=true;
            dfs(st,a,path,target-a[i],i+1);
            path.pop_back();
            st[i]=false;
        }    
    }
};

算法描述

每个物品限用一次 又可能存在重复元素 就是在01背包的基础上加了每个物品限用n次的要求 就是多重背包问题
那么这一题和上一题的差别就是多了一个每个物品限用n次的限制 只要加上这个限制上一题的代码就可以直接跑通了
这里一个简单的思路就是 先对所给数组排序 然后就是双指针得到个数的常规思路 然后枚举元素的时候除了不能超出背包体积 个数也不能超

dfs(多重背包思想)

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> combinationSum2(vector<int>& c, int target){
        sort(c.begin(),c.end());
        dfs(c,0,target);
        return res;
    }
    void dfs(vector<int>& c,int u,int target){
        if(target==0){
            res.push_back(path);
            return;
        }
        if(u==c.size()) return;
        int k=u+1;
        while(k<c.size() && c[k]==c[u]) k++;
        int cnt=k-u;
        for(int i=0;i*c[u]<=target && i<=cnt;i++){
            dfs(c,k,target-i*c[u]);
            path.push_back(c[u]);
        }
        for(int i=0;i*c[u]<=target && i<=cnt;i++){
            path.pop_back();
        }
    }
};
可乐大牛
关注
专栏目录
面试算法LeetCode刷题班
04-26
课程将程序员面试中常遇的算法与数据结构知识进行精简与归纳，细致入微地讲解笔试面试中的编程真题和相关知识点; 以leetcode.com、codeforces.com中的题目为例题，利用OJ刷题的方式提升学员的编码能力与解决算法面试题的能力
js-leetcode题解之第36-valid-sudoku.js
最新发布
10-14
js js_leetcode题解之第36-valid-sudoku.js
LeetCode究极班系列(6-10)
可乐大牛的博客
09-28 408
6. Z 字形变换 将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。 比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下： L C I R E T O E S I I G E D H N 之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“LCIRETOESIIGEDHN”。 请你实现这个将字符串进行指定行数变换的函数： string convert(string s, int numRows); 输入:
LeetCode究极刷题班
weixin_50385926的博客
01-02 361
LeetCode究极刷题班ing
LeetCode究极班系列(16-20)
可乐大牛的博客
10-04 253
16. 最接近的三数之和 给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。 输入：nums = [-1,2,1,-4], target = 1 输出：2 解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。 暴力枚举 class Solution { public: int threeSumClosest(vector<in
LeetCode究极班系列(31-35)
可乐大牛的博客
10-13 334
31. 下一个排列 实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。 如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。 必须原地修改，只允许使用额外常数空间。 以下是一些例子，输入位于左侧列，其相应输出位于右侧列。 1,2,3 → 1,3,2 3,2,1 → 1,2,3 1,1,5 → 1,5,1 算法描述 目标是找到第比当前序列大的序列的最小值 那么 显然为了使得找到的序列最小 我们从往前找 找到一个逆序 因为若是升序 在交换完了之后
leetcode双人赛-leetcode-python:leetcode-python
06-30
leetcode双人赛Leetcode Python 挑战 直到 2019-08-05 22:50:03，我已经解决了7 / 1072问题，而169仍然被锁定。 完成统计： Python：7 笔记： :locked: 意味着你需要从 LeetCode 购买一本书 力扣解决方案表 ID 标题 ...
leetcode2sumc-leetcode-cli:leetcode-cli
06-30
leetcode-cli 注意：这个存储库是为了临时使用而分叉的。 注意：从 webbrowser 复制 cookie 并使用leetcode user -c可以临时修复不能。 一个享受 leetcode 的高效 cli 工具！ 非常感谢 leetcode.com，一个非常棒的...
leetcode怎么销号-LeetCode-Top-Interview-Questions:LeetCode-Top-Interview-Qu
06-30
leetcode怎么销号 LeetCode便签 Linked List Cycle 问题描述 Given a linked list, determine if it has a cycle in it. Follow up:Can you solve it without using extra space? 解决思路 声明一个慢指针和一个快...
leetcode中文版-leetcode-cheat:leetcode-cheat的发布
06-29
leetcode-cheat 的发布 它是什么 ？ 这是一个chrome 扩展，可以帮助您更高效地使用 leetcode。您可以从 重要: leetcode-cheat 现在只支持中文版。 也就是说不完全支持leetcode.com，但是你可以用leetcode-cn.com代替...
老毛子百度云转存【2019-1-22】.txt
03-16
老毛子百度云转存工具 可以批量导入资源列表，支持密码，批量转存到自己的网盘。 转存结果可以导出。 附件是百度网盘地址。
LeetCode究极班系列(1-5)
可乐大牛的博客
09-26 369
1. 两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] 暴力枚举 class Solution { public: vector<int> twoSum(vec
《面试算法 LeetCode 刷题班》—— 1. 链表
Chris_zhangrx的博客
12-04 3105
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 1.链表 文章目录1.链表LeetCode 206 链表逆序 a （E）LeetCode 92 链表逆序 b（M）LeetCode 141 &amp;amp; 142 链表求环（M） （快慢指针问题）LeetCode 86 链表划分（M）LeetCode 21 排序链表合并（2个）（E）LeetCo...
LeetCode究极班系列(41-45)
可乐大牛的博客
10-21 239
41. 缺失的第一个正数 给你一个未排序的整数数组，请你找出其中没有出现的最小的正整数。 输入: [1,2,0] 输出: 3 提示： 你的算法的时间复杂度应为O(n)，并且只能使用常数级别的额外空间。 算法描述 将所有的数 存入set去重 然后从1开始枚举所有正整数 不存在就输出 哈希 class Solution { public: int firstMissingPositive(vector<int>& nums) { unordered_set
背包问题的DFS解法
飞鱼の博客
05-04 1282
Knapsack Problem 问题描述： 有n件物品，每件物品重w[i]，价值为c[i]。现在需要选出若干件物品放入一个容量为V的背包中，使得在选入背包的物品总重量不超过背包限重的情况下，让背包内的物品总价值达到最大。 DFS解法： 算法思想： 对于每件物品，有两种情况（选，或不选）。若选择该物品，则将更新背包内的总重与总价值量，若不选择该物品，则跳过它去判断下一件物品，当处理完n件...
《面试算法 LeetCode 刷题班》——4. 递归，回溯，分治
Chris_zhangrx的博客
11-28 2241
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 4. 递归，回溯，分治 文章目录4. 递归，回溯，分治LeetCode 78 求子级（M）LeetCode 90 求子集2（M）LeetCode 40 组合数之和2（M）LeetCode 22 生成括号（M）LeetCode 51 N 皇后（H）LeetCode 315 逆序数（H） Lee...
【leetcode刷题班】贪心题目求解
littlemichelle
02-18 1048
leetcode455、分糖果(easy) 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj &gt;= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大...
LeetCode题解PDF百度网盘下载
李rumor
01-31 4079
LeetCode题解PDF下载 链接: https://pan.baidu.com/s/13GslyxeHKe9wEz-MBYfH3Q 密码: 12fc 其他学习资源都整理在这个Github了： https://github.com/leerumor/ai-study 包含机器学习基础ML、深度学习基础DL、计算机视觉CV、自然语言处理NLP、推荐系统、语音识别、图神经网路、算法工程师面试题等众多学习资料，欢迎一起完善～ 注：以上资料全部来源于网络其他人的整理，我这里只是收集整理了他们的链接，如有侵权，
甜点(多重背包+二进制优化)
untilyouydc
11-06 1146
描述 小z准备举办一个比赛。他需要提供一些甜点给参赛者来补充能量。每种甜品有一定的能量ti和大小ui，且每种甜点最多有vi个。 小z准备用箱子来包装甜点。箱子可以容纳一定体积的甜点且需要一定的费用。小z有一种魔法，可以将一个甜点分成多份装在箱子里，最后再合在一起（但合成之后必须是完整的一个）。 小z想知道准备能量至少为P的甜点的最小大小和最少需要多少费用来购买箱子，如果最少费用超过小z所拥有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值