二分算法学习

news2024/11/14 22:05:02

🌼 扎着马尾的姑娘,笑容温柔很善良
自在的少年 - 要不要买菜 - 单曲 - 网易云音乐

前言

本来打算做蓝桥杯2022C++A组省赛F题青蛙过河的,看到标签显示"二分",第一时间竟然想不到二分是什么,所以来学习下

目录

🌼二分是什么 

🌼一,砍树

🌼二,手写快排

🌼三,阶乘末尾0的个数

🌼四,序列合并

代码1    优先队列 

代码2    二分 

🌼五,银行贷款

🌼总结


🌼二分是什么 

概念

部分知识来自    二分 - OI Wiki (oi-wiki.org)

挺好的算法搜索网站,大家可放到收藏夹,专门搜算法用

二分查找(binary search),也称折半搜索(half-interval search)或对数搜索(logarithmic search)

用来在有序数组(单调增减)中查找某一元素的算法

比如,在升序数组中

每次查找当前部分中间元素,如果中间元素是要找的,结束搜索

如果小于所查找的值,左侧只会更小,所以在右侧查找

如果大于,则在左侧查找

二分查找最优时间和空间复杂度都是O(1),最差时间和空间复杂度都是O(logn

模板 

模板只提供一个思路,不能照搬 

int binary_search(int left, int right, int key) 
{
    int ret = -1; //未搜索到数据返回-1下标
    int mid;
    while(left <= right) {
        mid = left + ((right - left) >> 1); //避免溢出,用该算法
        if(key > a[mid]) left = mid + 1;
        else if(key < a[mid]) right = mid - 1;
        else { //最后检测相等
            ret = mid;
            break;
        }
    }
    return ret; //单一出口
}

 对于一个长度为n的数组,若n是有符号数,当n >= 0, n >> 1比 n / 2更快,且只能用于整数

使用条件 

1,有序(广义有序,查找满足某种条件的最大最小值)

2,比如要找最大值,首先想到从小到大枚举,若答案单调,可使用二分提高效率

3,固定区间; 判断某个值是否符合条件; 可行解对于区间满足一定单调性

题目加深理解

🌼一,砍树

P1873 [COCI 2011/2012 #5] EKO / 砍树 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

标签: 二分, 普及/提高-

1,可以在1~10^9枚举,但是这种朴素写法会超时,只适合在蓝桥杯骗分

2,可以sort()排序再优化砍多少米

3,由于要学习二分,我们采用二分 

发现的问题 

1,right不要声明为全局变量,会与#include<iostream>库里的属性或方法重名

2,大数组,比如long long a[1000010];  要声明在主函数外作为全局变量,因为主函数内用存储,栈的空间没那么大,会溢出,导致调试时,无法输入,而全局变量在静态存储区分配,空间很大

3, left <= right  right = mid - 1  mid + 1  printf("%lld", mid - 1)这几行代码,需要自己多弄几组数据测试

否则会出现Ac30% 或50%等情况

4,最好将所有整型声明为long long,避免后续操作导致的溢出(注意,因为习惯性int i ,可能出错)

代码1  AC50% 

#include<iostream>
#include<cstdio> //scanf()
using namespace std;
long long n, m, sum, mid, a[1000010];
int main()
{
    long long right = 0, left = 0; //初始左右边界
    scanf("%lld%lld", &n, &m);
    for(int i = 0; i < n; ++i) {
        scanf("%lld", &a[i]);
        right = max(a[i], right); //最高的树作为初始右边界
    }
    while(left <= right) {
        sum = 0; //更新
        mid = (left + right) >> 1; //mid为伐木高度
        for(int i = 0; i < n; ++i)
            if(a[i] > mid) sum += a[i] - mid;
        if(sum < m) right = mid - 1;
        else left = mid + 1;
    }
    printf("%lld", mid - 1);
    return 0;
}

 代码1过了两个样例,但是在下面例子中输出了0,应该输出1才是

5 20
1 3 5 7 10

问题出在最后的printf(),不是mid - 1(50%),不是mid(50%),也不是left(wa),是right(100%)

代码逐行解析:

mid为伐木高度,但不是最终输出答案

left左边界,right右边界,数组a存储所有树木高度

sum为砍伐后获得树木总长度

关键1

第16行mid = (left + right) >> 1等价于mid = (left + right) / 2,位运算速度更快

关键2

第19~20行right = mid - 1和left = mid + 1

这三行实现了砍树高度的二分

由于题目要求的是,刚好能得到>=m米木材的临界点,所以输出right

Ac 100%代码 

#include<iostream>
#include<cstdio> //scanf()
using namespace std;
long long n, m, sum, mid, a[1000010];
int main()
{
    long long right = 0;
    scanf("%lld%lld", &n, &m);
    for(int i = 0; i < n; ++i) {
        scanf("%lld", &a[i]);
        right = max(a[i], right); //最高的树作为初始右边界
    }
    long long left = 0; //初始左边界
    while(left <= right) {
        sum = 0; //更新
        mid = (left + right) >> 1; //mid为伐木高度
        for(int i = 0; i < n; ++i)
            if(a[i] > mid) sum += a[i] - mid;
        if(sum < m) right = mid - 1;
        else left = mid + 1;
    }
    printf("%lld", right);
    return 0;
}

🌼二,手写快排

P1026 - 排序 - New Online Judge (ecustacm.cn)

​ 

标签: 入门题 

因为快排 = 二分 + 递归,所以通过再次手写快排加深对二分的理解

快速排序最好的时间复杂度和二分平均时间复杂度一样,都是O(logn),而最差时间复杂度为O(n^2) 

#include<iostream>
using namespace std;
int a[100010]; //声明为全局,不用传参
void quick_sort(int left, int right)
{
    if(left > right) return;
    int i = left, j = right, base = a[left];
    while(i < j) {
        while(i < j && a[j] >= base) j--; //j游标先行
        while(i < j && a[i] <= base) i++; //i游标后走
        //退出上面两循环后,i,j分别指向大于base和小于base的值
        if(i < j) {
            a[i] = a[i]^a[j];
            a[j] = a[i]^a[j];
            a[i] = a[i]^a[j]; //异或交换两数
        }
    }
    a[left] = a[j]; //j先行,此时i,j指向的元素必要小于基数
    a[j] = base; //交换完毕后,左边都小于base,右边都大于base
    quick_sort(left, j - 1); //对左边递归
    quick_sort(j + 1, right); //对右边递归
}
int main()
{
    int n;
    cin>>n;
    for(int i = 0; i < n; ++i) cin>>a[i];
    quick_sort(0, n - 1);
    for(int i = 0; i < n; ++i) cout<<a[i]<<" ";
    return 0;
}

核心代码也就十几行

🌼三,阶乘末尾0的个数

(一)标签:入门题

因为n!中的n可达10^9,直接递归肯定超时,我们转换个思路

1,求0的个数,也就是求n!能被10整除多少次

2,由于10 = 5 * 2,5 * 任意偶数都能得到10

3,所以转化为求n中5因子的个数

#include<iostream>
using namespace std;
int main()
{
    long long n;
    while(cin>>n) {
        int sum = 0; //sum = 0要放在外层while里
        while(n) {
            sum += n / 5;
            n /= 5;
        }
        cout<<sum<<endl;
    }
    return 0;
}

(二)标签:基础题,二分

首先,基于上一题,我们可以写个函数求n!中0的个数

其次,想要用二分来提高效率,首先得明确右边界,就是最大值

容易知道 100! 有24个0,同理 1000! 大约有240个0,所以要求10^8个0,大约得4*10^8阶乘

所以右边界给它算10^12,往大了开,反正long long到10^8

有一个坑,题目要求的是最小的N,比如输入2后,10!和12!都有2个0,这时你输出13就不对,因为不是最小的

第一次好歹还能输出个答案,虽然不是最小N,为了输出最小N,我加了一个限制条件,就输出了一堆屁 

一堆屁 

#include<iostream>
using namespace std;
long long q, flag = 1, ans, temp;
long long zero(long long n)
{
    int sum = 0;
    while(n) {
        sum += n / 5;
        n /= 5;
    }
    return sum;
}
long long check(long long q)
{
    long long left = 0, right = 1000000000000, mid; //10^12
    while(left <= right) {
        mid = (left + right) >> 1; //中间值
        if(zero(mid) < q) left = mid + 1;
        else if(zero(mid) > q) right = mid - 1;
        else {//检测相等
            return mid;
        }
    }
}
int main()
{
    cin>>q;
    while(1) {
        ans = check(q);
        temp = ans;
        while(zero(--temp) == q) ans--;
        cout<<ans;
        break;
    }
    return 0;
}
2
429496729635

 以前也遇到过类似情况,一时想不起来了

思路:同样是上一个代码的想法,找 n! 中 0 的个数,就是求 n 中 因子5的数量,忽略了这个思路,代码就复杂许多,各种出错AC不了不足为奇 

AC代码之❌ 

#include<cstdio> //scanf(), printf()
long long zero(long long n)
{
    long long sum = 0;
    while(n) {
        sum += n / 5;
        n /= 5;
    }
    return sum; //0的个数
}
int main()
{
    long long q;
    scanf("%lld", &q);
    for(int i = 1;; ++i) {
        if(zero(i * 5) == q) { //遍历时只需对5的倍数遍历即可
            printf("%lld", i * 5);
            break;
        }
        else if(zero(i * 5) < q && zero(i * 5 + 5) > q) {
            printf("No solution");
            break;
        }
    }
    return 0;
}
2
-8589934582

发现问题了吗,代码第15行,int i放入zero(long long)是不匹配的

AC代码之 

#include<cstdio> //scanf(), printf()
long long zero(long long n)
{
    long long sum = 0;
    while(n) {
        sum += n / 5;
        n /= 5;
    }
    return sum; //0的个数
}
int main()
{
    long long q;
    scanf("%lld", &q);
    for(long long i = 1;; ++i) {
        if(zero(i * 5) == q) { //遍历时只需对5的倍数遍历即可
            printf("%lld", i * 5);
            break;
        }
        else if(zero(i * 5) < q && zero(i * 5 + 5) > q) {
            printf("No solution");
            break;
        }
    }
    return 0;
}

不用二分了,有点麻烦,,,但是锻炼的效果已经达到了(好歹写了一堆屁出来) 

🌼四,序列合并

P1102 - 序列合并 - New Online Judge (ecustacm.cn)

​ 

标签:基础题,二分

可以用优先队列,也可以用二分

思路1    优先队列

我也第一次接触,先来个科普文

(6条消息) C++优先队列priority_queue详解_是一只派大鑫的博客-CSDN博客_priority_queue头文件

因为要输出前n个最小值,利用优先队列自动排序的特点很好做

默认是最大值优先队列,即最大值在顶端

priority_queue<int,vector<int>,less<int>>p2;//最大值优先队列
priority_queue<int,vector<int>,greater<int>>p3;//最小值优先队列

在这里,我们作个比较,的声明是这样的:

#include<stack> //st.pop(), st.push() 
int main()
{
    stack<int>st;
}

 而优先队列的声明,是这样的:

(注意,#include<queue>using namespace std;两行要配合使用)

#include<queue> 
using namespace std;
int main()
{
    priority_queue<int>q;
}

核心代码第24,25行,利用了最大值优先队列中,最大值始终在队首的特点

代码第17,18行,对数组a, b排序,是为了第27行可以break,不至于超时

代码1    优先队列 

#include<cstdio> //scanf(), printf()
#include<algorithm> //sort()
#include<queue> //1
using namespace std; //2

int a[100010], b[100010];
int main()
{
    priority_queue<int>q; //3
    int n, i, j;
    scanf("%d", &n);
    for(i = 0; i < n; ++i)
        scanf("%d", &a[i]);
    for(i = 0; i < n; ++i)
        scanf("%d", &b[i]); //输入
    sort(a, a + n);
    sort(b, b + n); //排序

    for(i = 0; i < n; ++i) q.push(a[0] + b[i]); //入队n个元素
    for(i = 1; i < n; ++i)
        for(j = 0; j < n; ++j) {
            if(a[i] + b[j] < q.top()) {
                q.pop(); //核心代码
                q.push(a[i] + b[j]); //核心代码
            }
            else break; //后面必定更大,可以直接break
        }
    //最大值优先队列,最大值在顶端,所以逆序保存
    for(i = n - 1; i >= 0; --i) {
        a[i] = q.top(); //最大值放最后
        q.pop(); //出队
    }
    for(int i = 0; i < n; ++i)
        printf("%d ", a[i]);
    return 0;
}

--------------------------------------------------------------------------------------------------------- 

思路2    二分 

代码中两层for遍历时,出现2次else break; 这步很重要,因为排序后单调递增,所以后续没必要比较,不用就超时

第二,由于要使用二分,加上单个数10^9,右边界最大2*10^9,左边界最大也可能接近2*10^9,所以相加时int会超限,所以用long long

当然,也可以mid = left + (right - left) >> 1,这样用int也是可以的

第一次敲出来后,在第40行报错 error: invalid types long long int ... ... for subscript

百度说

1,数组变量名敲错 / 未定义

2,数组超限

3,变量名数组名重复定义

4,个人变量名与C++库的变量名冲突

if(a[i][j] <= right) c[num++] = a[i][j];

原来是把a[i] + b[j]写成了a[i][j]🤦‍ 

注意!!! 不要照搬模板,比如下面核心代码中,第33,35,36行,

第33行要left < right,如果加上 = 会时间超限 AC 0%

第35,36行,如果改成right = mid, left = mid会超限并AC 20%

代码2    二分 

#include<iostream>
#include<cstdio> //scanf(), printf()
#include<algorithm> //sort()
using namespace std;
typedef long long LL;
LL a[100010], b[100010], c[100010], n, i, j;

bool check(long long x) //return false这样的,用bool
{
    LL ans = 0;
    for(i = 0; i < n; ++i)
        for(j = 0; j < n; ++j) {
            if(a[i] + b[j] <= x) ans++;
            else break; //这步很重要

            if(ans == n) return true; //x可能小了
        }
    return false; //x大了
}

int main()
{
    scanf("%d", &n);
    for(i = 0; i < n; ++i)
        scanf("%lld", &a[i]); //lld
    for(i = 0; i < n; ++i)
        scanf("%lld", &b[i]); //lld
    sort(a, a + n);
    sort(b, b + n);
    //初始左右边界
    LL left = a[0] + b[0], right = a[n - 1] + b[n - 1];
    //二分核心代码
    while(left < right) { //<
        LL mid = (left + right) >> 1;
        if(check(mid)) right = mid - 1; //mid - 1
        else left = mid + 1; //mid + 1
    }
    LL num = 0;
    for(i = 0; i < n; ++i)
        for(j = 0; j < n; ++j) {
            if(a[i] + b[j] <= right) c[num++] = a[i] + b[j];
            if(num == n) break;
        }
    sort(c, c + n);
    for(i = 0; i < n; ++i) printf("%lld ", c[i]); //记得用lld
    return 0;
}

🌼五,银行贷款

P1163 银行贷款 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

如果是正向(提供月利率求还清款项的月数),很简单

无奈本题反向,需要二分,无非就是写个正向的check()函数,主函数里二分即可 

标签:普及-,数学,二分

第一次敲出来了,但输出不对,debug半小时也没找到原因,写写改改太混乱了,所以重写

需要注意的是

1,先计算复利再还钱(第一个

2,printf()输出双精度要用%f,不能用%lf (第二个

3,因为求得是百分数,最后的mid要*100

AC 代码 

#include<cstdio> //scanf()
using namespace std; //cout
double debt, p, num; //欠款, 每月还款, 还清月数
double check(double m) //monthly interest月利率
{
    double d = debt, pp = p, n = num;
    while(n--) {
        d += d * m; //先计算复利, += 欠债 * 月利率
        d -= pp; //再还钱, -= 每月还款
    }
    return d; //返回剩余欠款
}
int main()
{
    scanf("%lf%lf%lf", &debt, &p, &num);
    double left = 0, right = 10; //1000%
    while(1) {
        double mid = (left + right) / 2;
        if(check(mid) < 0) left = mid;
        if(check(mid) > 0) right = mid;
        if(check(mid) == 0 || right - left < 0.0001) //精度
        {
            printf("%.1f", mid * 100); //输出%f就好
            break;
        }
    }
    return 0;
}

🌼总结

1,了解了二分模板和概念,比如使用于有序数组,比如明确左右边界

2,加强了对枚举遍历骗分的认识

3,大数组要声明为全局变量,long long可防止后续操作爆int

4,有简便方法就换简便方法,思路一变天地宽

5,输入的数,要与函数形参的类型对应

6,优先队列的声明

#include<queue> 
using namespace std;
priority_queue<int>q; //默认最大值优先队列
priority_queue<int,vector<int>,less<int>>p2;//最大值优先队列
priority_queue<int,vector<int>,greater<int>>p3;//最小值优先队列

7,二分遇到不需要再比较的情况,及时break

8,printf()输出双精度%f就行,%lf不行 

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

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

相关文章

传闻将与马云合作,涨了7倍的正大企业国际,还能跟风吗?

1月30日周一&#xff0c;港股正大企业国际逆势大涨68.35%&#xff0c;1月31日正大企业国际继续飙升&#xff0c;最高点涨超275%&#xff0c;收盘时涨幅达251.88%&#xff0c;成为2023年第一只翻倍的股票。今日早盘继续近40个点&#xff0c;还在持续发酵中。 消息面上&#xff…

Python+Go实践(电商架构一)

文章目录简介架构分析接口管理peeweeCURDGin获取请求参数protobuf验证表单中间件静态文件优雅退出小结简介 电商系统&#xff1a;后台管理前端商城 架构分析 传统的单体架构&#xff0c;以Django为例&#xff1b;之前写过flask开发微视频网站就是这样的架构 痛点分析及演进 …

Oracle数据库安装配置和卸载

Oracle数据库是一种网络上的数据库, 它在网络上支持多用户, 支持服务器/客户机等部署(或配置) 服务器与客户机是软件概念, 它们与计算机硬件不存在一一对应的关系. 即: 同一台计算机既可以充当服务器又可以充当客户机, 或者, 一台计算机只充当服务器或只充当充当客户机. Orac…

JAVA 老掉牙的面试问题 线程交替打印问题,分析实操一下

前言 新的一年了&#xff0c;首先是祝大家新年新气象&#xff0c;工作顺利&#xff0c;生活美满 。 万物复苏的一年&#xff0c; 大家都蠢蠢欲动&#xff01; 金三银四快来了&#xff0c; 机会多不多&#xff1f; ‘’满大街机会‘’ 好了不啰嗦&#xff0c;最近有比较多的小伙…

开关电源-TL431与光耦组成的电压反馈电路-TL431工作过程分析

开关电源&#xff1a;TL431与光耦组成的电压反馈电路 #开关电源#开关电源最基本的要求是输入电压变化时&#xff0c;输出电压保持恒定&#xff0c;而与此相关的测试如电压调整率、负载调整率等也是衡量开关电源性能的重要指标&#xff0c;实现输出电压恒定的方式是反馈&#x…

【Catalyst 9000上EEM的部署方法和示例,你看明白了吗?】

新的一年 新的征程 新的课程开班 等你来学&#xff01; EEM&#xff08;Embedded Event Manager&#xff09;作为一个自动化的脚本部署在设备上&#xff0c;可以根据指定的trigger来自动完成提前布置的任务&#xff0c;如信息的收集或特定的操作。一个完整的EEM需要包含Na…

Python学习-----起步2(变量与转义符)

目录 前言 Python变量/常量使用规则 基本数据变量类型 整形&#xff08;int&#xff09; 浮点型&#xff08;float&#xff09; 字符串类型&#xff08;str&#xff09; 布尔类型&#xff08;bool&#xff09; 转义符 习题 前言 在我们学习C语言时&#xff0c;我们学了很…

对象之间的拷贝

这里写目录标题Lambda 的 builderidea 自动生成插件 GenerateAllSetterMapStructDozer在开发的时候经常会有业务代码之间有很多的 JavaBean 之间的相互转化&#xff0c;比如 PO/DTO/VO/QueryParam 之间的转换问题&#xff0c;本文总结一下各种转换方法Lambda 的 builder 使用构…

有幸得到Alibaba内部Gradle实战笔记,趁机狂补

虽然一直在接触 Gradle&#xff0c;但对 Gradle 始终都有一些陌生感&#xff0c;表现在日常的开发中就是不敢随便改 build.gradle 文件&#xff0c;一旦 sync 出错&#xff0c;只会复制错误找谷歌&#xff0c;可是解决方案也不一定能够完美解决自己的问题。还有就是不熟悉 Grad…

黑客为什么都有一台笔记本电脑?

用一位程序员的话俩说&#xff1a;虽然我不是黑客&#xff0c;但是我也喜欢弄一些编程&#xff0c;对我而言&#xff0c;电脑就是我的工具&#xff0c;我的系统里面肯定有许多我自己写的程序&#xff0c;在我做任何操作的时候&#xff0c;我肯定使用我熟悉的软件&#xff0c;这…

创建者模式—工厂模式

目录 1.工厂模式 1.1概述 1.2简单工厂模式 1.2.1结构 1.2.2实现 1.2.3优缺点 1.2.4静态工厂 1.3工厂方法模式 1.3.1概念 1.3.2结构 1.3.3实现 1.3.4优缺点 1.4抽象工厂模式 1.4.1概念 1.4.2结构 1.4.3实现 1.4.4优缺点 1.工厂模式 1.1概述 需求&#xff1a;设…

易基因|细菌全基因组甲基化纳米孔测序(ONT):技术推介

大家好&#xff0c;这是专注表观组学十余年&#xff0c;领跑多组学科研服务的易基因。今天跟大家介绍一下易基因的新产品&#xff1a;细菌全基因组甲基化纳米孔测序&#xff08;ONT&#xff09;。表观修饰不需要改变DNA序列便能实现对性状的改变&#xff0c;表观修饰的改变与基…

什么是事务?什么是索引?什么是视图?

目录 一、事务 二、视图 1 、视图概念 2、为什么要使用视图 3 、性能问题 4 、定义视图 5、查看视图 6、删除视图 三、索引 1、引入索引的问题 2、索引是什么 3、索引为什么选择b树 一、事务 事务是什么&#xff1f; 事务是一个操作序列&#xff0c;这些操作要么都…

Python+Selenium+Unittest 之selenium2--元素定位1-简介

这篇先说下webdriver的几种元素定位方式&#xff0c;让大家有个大概的了解&#xff0c;UI自动化说白了就是使用代码代替人工去进行操作&#xff0c;在页面上&#xff0c;执行人员可以直接对看到的任何地方进行点击、拖动等操作&#xff0c;而代码的话需要识别到到底要点那个按钮…

生产制造业ERP管理系统对于制造企业的好处有哪些?

任何一家企业在管理当中都存在或多或少的问题&#xff0c;这些问题对企业的发展都形成了一定的阻碍。在生产制造业当中&#xff0c;由于每日的繁重的生产计划和大量的生产作业&#xff0c;使得企业管理存在一些问题&#xff0c;这些问题不利于生产的有序进行&#xff0c;从而阻…

图表控件LightningChart.NET 系列教程(八):用代码创建图表

LightningChart.NET SDK 是一款高性能数据可视化插件工具&#xff0c;由数据可视化软件组件和工具类组成&#xff0c;可支持基于 Windows 的用户界面框架&#xff08;Windows Presentation Foundation&#xff09;、Windows 通用应用平台&#xff08;Universal Windows Platfor…

【微服务】分布式事务Seata

分布式事务Seata1.分布式事务问题1.1.本地事务1.2.分布式事务2.理论基础2.1.CAP定理2.1.1.一致性2.1.2.可用性2.1.3.分区容错2.1.4.矛盾2.2.BASE理论2.3.解决分布式事务的思路3.初识Seata3.1.Seata的架构3.2.部署TC服务3.3.微服务集成Seata3.3.1.引入依赖3.3.2.配置TC地址3.3.3…

商用清洁机器人:科沃斯“破圈”、高仙机器人“纵深”

配图来自Canva可画 正所谓科技改变生活&#xff0c;机器人在人们日常生活中出现的频率正在逐步提高。同时&#xff0c;随着智能技术的不断迭代升级、用户需求的增多&#xff0c;机器人的应用场景逐步拓宽、功能形态也愈发多样化&#xff0c;比如配送机器人、医疗机器人、教育机…

Android 12.0 启动app时设置密码锁

1.前言 1.1概述 在12.0的系统产品开发中,对于限制某些app的启动的功能中,在项目中的需求是在点击app启动的时候,根据包名设置密码锁,当输入正确的密码的时候来启动这个app,否则 就不能启动这个app,达到限制使用app的目的,这就需要在app启动的时候,检测app的包名,然后在…

分布式架构的必问理论

基础理论&#xff1a; CAP理论&#xff1a; CAP理论是分布式系统设计中最基础、也是最为关键的理论&#xff0c;它指出&#xff0c;分布式数据存储不可能同时满足以下三个条件。 一致性&#xff08;Consistency&#xff09;&#xff1a;每次读取要么获得最近写入的数据&…