代码随想录拓展day7 649. Dota2 参议院；1221. 分割平衡字符串；5.最长回文子串；132. 分割回文串 II；673.最长递增子序列的个数

news2024/9/25 12:32:15

代码随想录拓展day7 649. Dota2 参议院；1221. 分割平衡字符串；5.最长回文子串；132. 分割回文串 II；673.最长递增子序列的个数

贪心和动态规划的题目。因为贪心其实没什么规律，所以就简要记录了。

649. Dota2 参议院

https://leetcode.cn/problems/dota2-senate/

使用flag标记前后的方式很巧妙。

思路

这道题 题意太绕了，我举一个更形象的例子给大家捋顺一下。

例如输入"RRDDD"，执行过程应该是什么样呢？

  • 第一轮：senate[0]的R消灭senate[2]的D，senate[1]的R消灭senate[3]的D，senate[4]的D消灭senate[0]的R，此时剩下"RD"，第一轮结束！
  • 第二轮：senate[0]的R消灭senate[1]的D，第二轮结束
  • 第三轮：只有R了，R胜利

估计不少同学都困惑，R和D数量相同怎么办，究竟谁赢，其实这是一个持续消灭的过程！ 即：如果同时存在R和D就继续进行下一轮消灭，轮数直到只剩下R或者D为止！

那么每一轮消灭的策略应该是什么呢？

例如：RDDRD

第一轮：senate[0]的R消灭senate[1]的D，那么senate[2]的D，是消灭senate[0]的R还是消灭senate[3]的R呢？

当然是消灭senate[3]的R，因为当轮到这个R的时候，它可以消灭senate[4]的D。

所以消灭的策略是，尽量消灭自己后面的对手，因为前面的对手已经使用过权利了，而后序的对手依然可以使用权利消灭自己的同伴！

那么局部最优：有一次权利机会，就消灭自己后面的对手。全局最优：为自己的阵营赢取最大利益。

局部最优可以退出全局最优，举不出反例，那么试试贪心。

代码实现

实现代码，在每一轮循环的过程中，去过模拟优先消灭身后的对手，其实是比较麻烦的。

这里有一个技巧，就是用一个变量记录当前参议员之前有几个敌对对手了，进而判断自己是否被消灭了。这个变量我用flag来表示。

C++代码如下：

class Solution {
public:
    string predictPartyVictory(string senate) {
        // R = true表示本轮循环结束后，字符串里依然有R。D同理
        bool R = true, D = true;
        // 当flag大于0时，R在D前出现，R可以消灭D。当flag小于0时，D在R前出现，D可以消灭R
        int flag = 0;
        while (R && D) { // 一旦R或者D为false，就结束循环，说明本轮结束后只剩下R或者D了
            R = false;
            D = false;
            for (int i = 0; i < senate.size(); i++) {
                if (senate[i] == 'R') {
                    if (flag < 0) senate[i] = 0; // 消灭R，R此时为false
                    else R = true; // 如果没被消灭，本轮循环结束有R
                    flag++;
                }
                if (senate[i] == 'D') {
                    if (flag > 0) senate[i] = 0;
                    else D = true;
                    flag--;
                }
            }
        }
        // 循环结束之后，R和D只能有一个为true
        return R == true ? "Radiant" : "Dire";
    }
};

1221. 分割平衡字符串

https://leetcode.cn/problems/split-a-string-in-balanced-strings/

非常简单粗暴，从头开始遇到平衡字符串计数就行了。唯一的trick就是用一个count来判断平衡字符串。

思路

这道题目看起来好像很复杂，其实是非常简单的贪心。

从前向后遍历，只要遇到平衡子串，计数就+1，遍历一遍即可。

局部最优：从前向后遍历，只要遇到平衡子串 就统计

全局最优：统计了最多的平衡子串。

局部最优可以推出全局最优，举不出反例，那么就试试贪心。

例如，LRLR 这本身就是平衡子串 , 但要遇到LR就可以分割。

C++代码如下：

class Solution {
public:
    int balancedStringSplit(string s) {
        int result = 0;
        int count = 0;
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == 'R') count++;
            else count--;
            if (count == 0) result++;
        }
        return result;
    }
};

5.最长回文子串

https://leetcode.cn/problems/longest-palindromic-substring/

和回文子串的长度相似，只不过这次要记录最大长度。

动态规划

动规五部曲：

  1. 确定dp数组（dp table）以及下标的含义

布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。

  1. 确定递推公式

在确定递推公式时，就要分析如下几种情况。

整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。

当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。

当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况

  • 情况一：下标i 与 j相同，同一个字符例如a，当然是回文子串
  • 情况二：下标i 与 j相差为1，例如aa，也是文子串
  • 情况三：下标：i 与 j相差大于1的时候，例如cabac，此时s[i]与s[j]已经相同了，我们看i到j区间是不是回文子串就看aba是不是回文就可以了，那么aba的区间就是 i+1 与 j-1区间，这个区间是不是回文就看dp[i + 1][j - 1]是否为true。

以上三种情况分析完了，那么递归公式如下：

if (s[i] == s[j]) {
    if (j - i <= 1) { // 情况一 和 情况二
        dp[i][j] = true;
    } else if (dp[i + 1][j - 1]) { // 情况三
        dp[i][j] = true;
    }
}

注意这里我没有列出当s[i]与s[j]不相等的时候，因为在下面dp[i][j]初始化的时候，就初始为false。

在得到[i,j]区间是否是回文子串的时候，直接保存最长回文子串的左边界和右边界，代码如下：

if (s[i] == s[j]) {
    if (j - i <= 1) { // 情况一 和 情况二
        dp[i][j] = true;
    } else if (dp[i + 1][j - 1]) { // 情况三
        dp[i][j] = true;
    }
}
if (dp[i][j] && j - i + 1 > maxlenth) {
    maxlenth = j - i + 1;
    left = i;
    right = j;
}
  1. dp数组如何初始化

dp[i][j]可以初始化为true么？ 当然不行，怎能刚开始就全都匹配上了。

所以dp[i][j]初始化为false。

  1. 确定遍历顺序

遍历顺序可有有点讲究了。

首先从递推公式中可以看出，情况三是根据dp[i + 1][j - 1]是否为true，在对dp[i][j]进行赋值true的。

dp[i + 1][j - 1] 在 dp[i][j]的左下角，如图：

在这里插入图片描述

如果这矩阵是从上到下，从左到右遍历，那么会用到没有计算过的dp[i + 1][j - 1]，也就是根据不确定是不是回文的区间[i+1,j-1]，来判断了[i,j]是不是回文，那结果一定是不对的。

所以一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。

有的代码实现是优先遍历列，然后遍历行，其实也是一个道理，都是为了保证dp[i + 1][j - 1]都是经过计算的。

代码如下：

for (int i = s.size() - 1; i >= 0; i--) { // 注意遍历顺序
    for (int j = i; j < s.size(); j++) {
        if (s[i] == s[j]) {
            if (j - i <= 1) { // 情况一 和 情况二
                dp[i][j] = true;
            } else if (dp[i + 1][j - 1]) { // 情况三
                dp[i][j] = true;
            }
        }
        if (dp[i][j] && j - i + 1 > maxlenth) {
            maxlenth = j - i + 1;
            left = i;
            right = j;
        }
    }

}
  1. 举例推导dp数组

举例，输入：“aaa”，dp[i][j]状态如下：

在这里插入图片描述

注意因为dp[i][j]的定义，所以j一定是大于等于i的，那么在填充dp[i][j]的时候一定是只填充右上半部分。

以上分析完毕，C++代码如下：

class Solution {
public:
    string longestPalindrome(string s) {
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        int maxlenth = 0;
        int left = 0;
        int right = 0;
        for (int i = s.size() - 1; i >= 0; i--) {
            for (int j = i; j < s.size(); j++) {
                if (s[i] == s[j]) {
                    if (j - i <= 1) { // 情况一 和 情况二
                        dp[i][j] = true;
                    } else if (dp[i + 1][j - 1]) { // 情况三
                        dp[i][j] = true;
                    }
                }
                if (dp[i][j] && j - i + 1 > maxlenth) {
                    maxlenth = j - i + 1;
                    left = i;
                    right = j;
                }
            }

        }
        return s.substr(left, right - left + 1);
    }
};

或者也可以在更新dp的时候，就把当前起止位置的最大回文串长度作为dp值更新。

class Solution {
public:
    string longestPalindrome(string s) {
        vector<vector<int>> dp(s.size(), vector<int> (s.size(), 0));
        int maxLength = 0;
        int left = 0;

        for(int i = s.size()-1; i>=0; i--){
            for(int j = i; j<s.size(); j++){ 
                if(s[i] == s[j]){
                    if(j-i == 0){
                        dp[i][j] = 1;
                    } else if (j-i == 1){
                        dp[i][j] = 2;
                    } else if (dp[i+1][j-1] != 0) {
                        dp[i][j] = dp[i+1][j-1] + 2;
                    }
                }
                if(dp[i][j] > maxLength){
                    left = i;
                    maxLength = dp[i][j];
                }
            }
        }
        return s.substr(left, maxLength);
    }
};

132. 分割回文串 II

https://leetcode.cn/problems/palindrome-partitioning-ii/

这个dp的递推公式不是很好想到，在代码中的实现也要多注意。当0到 i 是回文字符串的时候，最小切割次数就是0了，也就是不用切割。

思路

本题呢其实也可以使用回溯法，只不过会超时！（通过记忆化回溯，也可以过，感兴趣的同学可以自行研究一下）

我们来讲一讲如何使用动态规划，来解决这道题目。

动规五部曲分析如下：

  1. 确定dp数组（dp table）以及下标的含义

dp[i]：范围是[0, i]的回文子串，最少分割次数是dp[i]。

  1. 确定递推公式

来看一下由什么可以推出dp[i]。

如果要对长度为[0, i]的子串进行分割，分割点为j。

那么如果分割后，区间[j + 1, i]是回文子串，那么dp[i] 就等于 dp[j] + 1。

这里可能有同学就不明白了，为什么只看[j + 1, i]区间，不看[0, j]区间是不是回文子串呢？

那么在回顾一下dp[i]的定义： 范围是[0, i]的回文子串，最少分割次数是dp[i]。

[0, j]区间的最小切割数量，我们已经知道了就是dp[j]。

此时就找到了递推关系，当切割点j在[0, i] 之间时候，dp[i] = dp[j] + 1;

本题是要找到最少分割次数，所以遍历j的时候要取最小的dp[i]。

所以最后递推公式为：dp[i] = min(dp[i], dp[j] + 1);

注意这里不是要 dp[j] + 1 和 dp[i]去比较，而是要在遍历j的过程中取最小的dp[i]！

可以有dp[j] + 1推出，当[j + 1, i] 为回文子串

  1. dp数组如何初始化

首先来看一下dp[0]应该是多少。

dp[i]： 范围是[0, i]的回文子串，最少分割次数是dp[i]。

那么dp[0]一定是0，长度为1的字符串最小分割次数就是0。这个是比较直观的。

在看一下非零下标的dp[i]应该初始化为多少？

在递推公式dp[i] = min(dp[i], dp[j] + 1) 中我们可以看出每次要取最小的dp[i]。

那么非零下标的dp[i]就应该初始化为一个最大数，这样递推公式在计算结果的时候才不会被初始值覆盖！

如果非零下标的dp[i]初始化为0，在那么在递推公式中，所有数值将都是零。

非零下标的dp[i]初始化为一个最大数。

代码如下：

vector<int> dp(s.size(), INT_MAX);
dp[0] = 0;

其实也可以这样初始化，更具dp[i]的定义，dp[i]的最大值其实就是i，也就是把每个字符分割出来。

所以初始化代码也可以为：

vector<int> dp(s.size());
for (int i = 0; i < s.size(); i++) dp[i] = i;
  1. 确定遍历顺序

根据递推公式：dp[i] = min(dp[i], dp[j] + 1);

j是在[0，i]之间，所以遍历i的for循环一定在外层，这里遍历j的for循环在内层才能通过 计算过的dp[j]数值推导出dp[i]。

代码如下：

for (int i = 1; i < s.size(); i++) {
    if (isPalindromic[0][i]) { // 判断是不是回文子串
        dp[i] = 0;
        continue;
    }
    for (int j = 0; j < i; j++) {
        if (isPalindromic[j + 1][i]) {
            dp[i] = min(dp[i], dp[j] + 1);
        }
    }
}

大家会发现代码里有一个isPalindromic函数，这是一个二维数组isPalindromic[i][j]，记录[i, j]是不是回文子串。

所以先用一个二维数组来保存整个字符串的回文情况。

代码如下：

vector<vector<bool>> isPalindromic(s.size(), vector<bool>(s.size(), false));
for (int i = s.size() - 1; i >= 0; i--) {
    for (int j = i; j < s.size(); j++) {
        if (s[i] == s[j] && (j - i <= 1 || isPalindromic[i + 1][j - 1])) {
            isPalindromic[i][j] = true;
        }
    }
}
  1. 举例推导dp数组

以输入：“aabc” 为例：

在这里插入图片描述

以上分析完毕，代码如下：

class Solution {
public:
    int minCut(string s) {
        vector<vector<bool>> isPalindromic(s.size(), vector<bool>(s.size(), false));
        for (int i = s.size() - 1; i >= 0; i--) {
            for (int j = i; j < s.size(); j++) {
                if (s[i] == s[j] && (j - i <= 1 || isPalindromic[i + 1][j - 1])) {
                    isPalindromic[i][j] = true;
                }
            }
        }
        // 初始化
        vector<int> dp(s.size(), 0);
        for (int i = 0; i < s.size(); i++) dp[i] = i;

        for (int i = 1; i < s.size(); i++) {
            if (isPalindromic[0][i]) {
                dp[i] = 0;
                continue;
            }
            for (int j = 0; j < i; j++) {
                if (isPalindromic[j + 1][i]) {
                    dp[i] = min(dp[i], dp[j] + 1);
                }
            }
        }
        return dp[s.size() - 1];

    }
};

673.最长递增子序列的个数

https://leetcode.cn/problems/number-of-longest-increasing-subsequence/

第一次遇到两个dp数组的题目。自己基本没想到。记录一下。

思路

  1. 确定dp数组（dp table）以及下标的含义

这道题目我们要一起维护两个数组。

dp[i]：i之前（包括i）最长递增子序列的长度为dp[i]

count[i]：以nums[i]为结尾的字符串，最长递增子序列的个数为count[i]

  1. 确定递推公式

在300.最长上升子序列 中，我们给出的状态转移是：

if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

即：位置i的最长递增子序列长度 等于j从0到i-1各个位置的最长升序子序列 + 1的最大值。

本题就没那么简单了，我们要考虑两个维度，一个是dp[i]的更新，一个是count[i]的更新。

那么如何更新count[i]呢？

以nums[i]为结尾的数组，最长递增子序列的个数为count[i]。

那么在nums[i] > nums[j]前提下，如果在[0, i-1]的范围内，找到了j，使得dp[j] + 1 > dp[i]，说明找到了一个更长的递增子序列。

那么以j为结尾的子串的最长递增子序列的个数，就是最新的以i为结尾的子序列的最长递增子序列的个数，即：count[i] = count[j]。

在nums[i] > nums[j]前提下，如果在[0, i-1]的范围内，找到了j，使得dp[j] + 1 == dp[i]，说明找到了两个相同长度的递增子序列。

那么以i为结尾的子串的最长递增子序列的个数 就应该加上以j为结尾的子序列的最长递增子序列的个数，即：count[i] += count[j];

代码如下：

if (nums[i] > nums[j]) {
    if (dp[j] + 1 > dp[i]) {
        count[i] = count[j];
    } else if (dp[j] + 1 == dp[i]) {
        count[i] += count[j];
    }
    dp[i] = max(dp[i], dp[j] + 1);
}

当然也可以这么写：

if (nums[i] > nums[j]) {
    if (dp[j] + 1 > dp[i]) {
        dp[i] = dp[j] + 1; // 更新dp[i]放在这里，就不用max了
        count[i] = count[j];
    } else if (dp[j] + 1 == dp[i]) {
        count[i] += count[j];
    }
}

这里count[i]记录了以nums[i]为结尾的字符串，最长递增子序列的个数。dp[i]记录了i之前（包括i）最长递增序列的长度。

题目要求最长递增序列的长度的个数，我们应该把最长长度记录下来。

代码如下：

for (int i = 1; i < nums.size(); i++) {
    for (int j = 0; j < i; j++) {
        if (nums[i] > nums[j]) {
            if (dp[j] + 1 > dp[i]) {
                count[i] = count[j];
            } else if (dp[j] + 1 == dp[i]) {
                count[i] += count[j];
            }
            dp[i] = max(dp[i], dp[j] + 1);
        }
        if (dp[i] > maxCount) maxCount = dp[i]; // 记录最长长度
    }
}
  1. dp数组如何初始化

再回顾一下dp[i]和count[i]的定义

count[i]记录了以nums[i]为结尾的字符串，最长递增子序列的个数。

那么最少也就是1个，所以count[i]初始为1。

dp[i]记录了i之前（包括i）最长递增序列的长度。

最小的长度也是1，所以dp[i]初始为1。

代码如下：

vector<int> dp(nums.size(), 1);
vector<int> count(nums.size(), 1);

其实动规的题目中，初始化很有讲究，也很考察对dp数组定义的理解。

  1. 确定遍历顺序

dp[i] 是由0到i-1各个位置的最长升序子序列 推导而来，那么遍历i一定是从前向后遍历。

j其实就是0到i-1，遍历i的循环里外层，遍历j则在内层，代码如下：

for (int i = 1; i < nums.size(); i++) {
    for (int j = 0; j < i; j++) {
        if (nums[i] > nums[j]) {
            if (dp[j] + 1 > dp[i]) {
                count[i] = count[j];
            } else if (dp[j] + 1 == dp[i]) {
                count[i] += count[j];
            }
            dp[i] = max(dp[i], dp[j] + 1);
        }
        if (dp[i] > maxCount) maxCount = dp[i];
    }
}

最后还有再遍历一遍dp[i]，把最长递增序列长度对应的count[i]累计下来就是结果了。

代码如下：

for (int i = 1; i < nums.size(); i++) {
    for (int j = 0; j < i; j++) {
        if (nums[i] > nums[j]) {
            if (dp[j] + 1 > dp[i]) {
                count[i] = count[j];
            } else if (dp[j] + 1 == dp[i]) {
                count[i] += count[j];
            }
            dp[i] = max(dp[i], dp[j] + 1);
        }
        if (dp[i] > maxCount) maxCount = dp[i];
    }
}
int result = 0; // 统计结果
for (int i = 0; i < nums.size(); i++) {
    if (maxCount == dp[i]) result += count[i];
}

统计结果，可能有的同学又有点看懵了，那么就再回顾一下dp[i]和count[i]的定义。

  1. 举例推导dp数组

输入：[1,3,5,4,7]

在这里插入图片描述

如果代码写出来了，怎么改都通过不了，那么把dp和count打印出来看看对不对！

以上分析完毕，C++整体代码如下：

class Solution {
public:
    int findNumberOfLIS(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size();
        vector<int> dp(nums.size(), 1);
        vector<int> count(nums.size(), 1);
        int maxCount = 0;
        for (int i = 1; i < nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    if (dp[j] + 1 > dp[i]) {
                        dp[i] = dp[j] + 1;
                        count[i] = count[j];
                    } else if (dp[j] + 1 == dp[i]) {
                        count[i] += count[j];
                    }
                }
                if (dp[i] > maxCount) maxCount = dp[i];
            }
        }
        int result = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (maxCount == dp[i]) result += count[i];
        }
        return result;
    }
};
  • 时间复杂度：O(n^2)
  • 空间复杂度：O(n)

还有O(nlog n)的解法，使用树状数组。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/140370.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数据可视化系列-04数据大屏基础知识

数据可视化系列-04数据大屏基础知识

文章目录5.销售数据看板5.1 了解数据大屏基础知识1.数据大屏简介&#xff1a;2.数据大屏使用场景3.数据大屏分类5.2 数据大屏的设计&#xff1a;1.大屏前端设计流程2.数据大屏设计尺寸解析3.可视化视觉设计5.3 大屏开发工具DataV&#xff1a;1.DataV数据可视化简介2.优势3.Data…
阅读更多...
植物大战僵尸：遍历向日葵的生产速度

植物大战僵尸：遍历向日葵的生产速度

找到向日葵的吐出阳光的速度&#xff0c;向日葵生产阳光是一个周期性的,所以其内部是有一个计时器控制的,我们只要找到这个计时器并改写它的定时时间即可完成无限吐阳光的作用 向日葵的遍历技巧: 首先种下一个向日葵 -> 然后CE马上搜索->未知初始化回到游戏->然后在…
阅读更多...
关于单相智能多用户远程预付费控系统的优化设计研究

关于单相智能多用户远程预付费控系统的优化设计研究

摘要&#xff1a;由于现有系统仅对电表数据进行读取操作&#xff0c;存在成本较高和耗时较长的问题&#xff0c;为此对单相智能多用户远程预付费控系统优化设计进行研究。选择电能表子系统作为优化对象&#xff0c;选取78KO527A微控制器作为电能表子系统的控制核心&#xff0c;…
阅读更多...
Java 并发编程 （三）Phaser

Java 并发编程 （三）Phaser

#Phaser 功能介绍 CyclicBarrier 解决了 CountDownLatch的缺点&#xff0c;但是其本身也仍然具备一定的缺陷&#xff0c;比如不可以动态添加parties 调用一次await 仅占用1个parties public class MyPhaser {private Phaser phaser new Phaser(3);public void testA(){System…
阅读更多...
微信过期文件怎么找回？2个方法，轻松解决

微信过期文件怎么找回？2个方法，轻松解决

现在很多小伙伴都喜欢使用微信发送文字、图片、语音、照片、文件等内容给对方。可是在其中&#xff0c;文件内容比较特殊。如果没有及时进行查看&#xff0c;过了一段时间就会变成过期文件&#xff0c;无法再进行查看了。微信过期文件怎么找回&#xff1f;今天小编分享2个简单好…
阅读更多...
微型消防站一体化指挥作战解决方案

微型消防站一体化指挥作战解决方案

一、政策要求 近年政府对社区微型消防站提出了新的建设要求&#xff1a; 1、 大力发展多种形式消防队伍&#xff0c;逐步加强现役消防力量建设&#xff0c;发展政府专职消防队&#xff0c;企业事业单位专职消防队和志愿消防队。 2、 明确城市消防安全布局和公共消防设施的消…
阅读更多...
vue 可视化表单设计器 自定义组件

vue 可视化表单设计器 自定义组件

有一款基于vue的可视化表单编辑器&#xff0c;直接双击或者拖拽组件&#xff0c;便可以创建一个表单&#xff0c;非常方便。今天为大家介绍这款编辑器&#xff1a; 官方地址&#xff1a;Variant Form - 可视化低代码表单 github地址&#xff1a;https://github.com/vform666/…
阅读更多...
Redshift渲染器为什么这么受欢迎？

Redshift渲染器为什么这么受欢迎？

Redshift是用于高质量制作工作的渲染器 。它是很快的渲染引擎&#xff0c;并且可以很好地与许多第三方插件配合使用。在本文中&#xff0c;让我们深入了解Redshift的更多细节。什么是 Redshift 及其工作原理&#xff1f;Redshift 是一种有偏见的 GPU 渲染引擎&#xff0c;它支持…
阅读更多...
【回答问题】ChatGPT上线了！给我推荐20个比较流行的OCR模型

【回答问题】ChatGPT上线了！给我推荐20个比较流行的OCR模型

给我推荐20个比较流行的OCR模型 好的&#xff0c;以下是我为你推荐的 20 个比较流行的 OCR 模型。 Tesseract CuneiForm Ocrad GOCR OCRopus OCR-ICR Ocropy Ocrad.js Ocracoke Ocralysis Ocrinum Ocrmypdf Ocrsaurus Ocrdroid Ocr-textscan Ocrfeeder Ocrmypicture Ocrus Oc…
阅读更多...
RHCE-chrony服务部署

RHCE-chrony服务部署

目录 要求&#xff1a; 思路&#xff1a; 配置过程&#xff1a; a: 1.开启两台服务器&#xff0c;开启chrony服务。 2.部署chrony服务 查看chrony服务状态 b: 区别&#xff1a; 配置过程: 修改完配置后&#xff0c;重启chrony服务 查看chrony状态&#xff1a; 小结一…
阅读更多...
element-ui 多选框和级联选择的部分bug以及解决方法

element-ui 多选框和级联选择的部分bug以及解决方法

前言 最近在开发一款使用了 element-ui 的低代码设计器&#xff0c;在开发的过程当中碰到了一些关于 element-ui 组件本身不合理的地方&#xff0c;并且在百度的基础上自己去阅读了一下 element-ui 的源码&#xff0c;也找出了这些问题的一个解决方案&#xff0c;下面就来看一…
阅读更多...
steam搬砖是什么？怎么做呀？

steam搬砖是什么？怎么做呀？

steam平台是什么&#xff1f;它是国外一个集全球大部分网游于一体的游戏平台&#xff0c;玩过绝地求生端游&#xff08;吃鸡&#xff09;&#xff0c;csgo的朋友&#xff0c;对它都不陌生&#xff0c;就像国内的Wegame一样&#xff0c;现在玩英雄联盟的&#xff0c;都是通过Weg…
阅读更多...
排序算法之冒泡算法

排序算法之冒泡算法

目录 排序算法介绍 冒泡排序 算法流程 算法实现 python C 排序算法介绍 《Hello算法》是GitHub上一个开源书籍&#xff0c;对新手友好&#xff0c;有大量的动态图&#xff0c;很适合算法初学者自主学习入门。而我则是正式学习算法&#xff0c;以这本书为参考&#xff0c…
阅读更多...
返回数组所有元素中或每行(列)中，最小值的位置（位置号从0开始）：argmin()函数

返回数组所有元素中或每行(列)中，最小值的位置（位置号从0开始）：argmin()函数

【小白从小学Python、C、Java】 【计算机等级考试500强双证书】 【Python-数据分析】 返回数组所有元素中或每行(列)中 最小值的位置&#xff08;位置号从0开始&#xff09; argmin()函数 选择题 下列说法错误的是? import numpy as np a np.array([[10,20,30,40],[15,20,25…
阅读更多...
Electron 企业级应用开发实战（二）

Electron 企业级应用开发实战（二）

这一讲会重点介绍如何集成 Node.js、使用 preload 脚本、进程间双向通信、上下文隔离等&#xff0c;为大家揭开 Electron 更强大的能力。 集成 Node.js 企业级桌面应用的资源都是本地化的&#xff0c;离线也能使用&#xff0c;所以需要把 html、js、css 这些资源都打包进去&a…
阅读更多...
独立光伏-电池-柴油发电机组的能源管理系统的主干网研究（Matlab代码实现）

独立光伏-电池-柴油发电机组的能源管理系统的主干网研究（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
ESPI3接收机

ESPI3接收机

18320918653 ESPI3 ESPI3|R&S ESPI3|二手EMI接收机|EMI预认证测试接收机|罗德与施瓦茨|EMC接收机|9KHz至3GHz品 牌&#xff1a;德国罗德与施瓦茨 | R&S | Rohde&Schwarz处于预认证级别的 R&S ESPI测试接收机有两种型号, 集成了罗德与施瓦茨公司认证级EMI测试…
阅读更多...
springboot：除了OpenOffice还可以用它轻松实现文档在线预览功能【附带源码】

springboot：除了OpenOffice还可以用它轻松实现文档在线预览功能【附带源码】

0. 引言 我们在项目中常常需要实现文档在线预览的功能&#xff0c;而文档种类繁多&#xff0c;除了pdf&#xff0c;还有word、text、excel、甚至还有mp3,mp4等多媒体文件。常用的手段是通过OpenOffice来将文档转换为pdf实现预览&#xff0c;本期我们就来看如何通过kkFileView实…
阅读更多...
rabbitmq基础10——消息追踪、Shovel插件的web端使用和命令使用

rabbitmq基础10——消息追踪、Shovel插件的web端使用和命令使用

文章目录一、消息追踪1.1 Firehose功能1.1.1 开启与关闭1.1.2 测试1.1.3 总结1.2 rabbitmq_tracing 插件1.2.1 定义trace规则1.2.2 测试1.2.2.1 与Firehose之间的优先级二、Shovel插件2.1 实现原理2.1.1 从队列到交换器2.1.2 从队列到队列2.1.3 交换器到交换器2.2 Shovel 插件使…
阅读更多...
大小端转换

大小端转换

一、名词解释首先解释一下大端模式和小端模式。小端模式&#xff0c;也叫小端存储&#xff1a;Little-Endian就是低位字节排放在内存的低地址端&#xff0c;高位字节排放在内存的高地址端。大端模式&#xff0c;也叫大端存储&#xff1a;Big-Endian就是高位字节排放在内存的低地…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023