NOIP 2021 第一题 报数 number 游走在超时的边缘(不定长数组) 10分+30分+50分(纯暴力)+70分(约数范围缩到sqrt(x)之内 4倍2倍重复的筛法 )+100分(查找优化)

2023-12-29 06:10
文章标签 数组 优化 查找 100 重复 30 不定 number 2021 约数 超时 游走 50 暴力 noip 70 sqrt 报数 筛法 缩到

本文主要是介绍NOIP 2021 第一题 报数 number 游走在超时的边缘(不定长数组) 10分+30分+50分(纯暴力)+70分(约数范围缩到sqrt(x)之内 4倍2倍重复的筛法 )+100分(查找优化)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

总目录详见：NOIP 提高组 复赛 试题 目录 信奥 历年

在线测评地址：洛谷 P7960 [NOIP2021] 报数

1.10分

对于10% 的数据，T≤10，x≤100。

纯暴力，极限情况，在x=100中傻傻找约数,1,2,3,......,99,100的方式，查找100次，再对约数进行判定，约数中数字是否含有7(极限是每个约数2次)，约数是否是7的倍数(极限是每个约数1次)，故此时对于每个极限计算次数是100*(2+1)=300，这是找一个数的情况，在x≤100中，对应最多找数的情况，要编写代码测试，之后，才知道，预计下一个符合条件的数字间隔最大在11左右。因极限情况T=10，总次数是300*11*10=33000，不超时。

后记，可以手工算出110内的数据，打上标记，程序进行处理，10分就拿到了。

2.30分

对于 30% 的数据，T≤100，x≤1000。

纯暴力，极限情况，在x=1000中傻傻找约数,1,2,3,......,999,1000的方式，查找1000次，再对约数进行判定，约数中数字是否含有7(极限是每个约数3次)，约数是否是7的倍数(极限是每个约数1次)，故此时对于每个极限计算次数是1000*(3+1)=4000，这是找一个数的情况，在x≤1000中，对应最多找数的情况，要编写代码测试，之后，才知道，预计下一个符合条件的数字间隔最大在11左右。因极限情况T=100，总次数是4000*11*100=4400000，不超时。

50分代码如下：

#include <bits/stdc++.h>
using namespace std;
bool find7(int a){//判断数a是否被7整除,是否某位上包含7 if(a%7==0)return 1;while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
bool isBad(int x){//判断x中所有因数是否包含7 int a;for(a=1;a<=x;a++){if(x%a==0){//a是约数 if(find7(a)==1){break;} }}if(a==x+1)return 0;//x中不包含7 else return 1;//x中包含有7 
}
int main(){int t,x,a,b;scanf("%d",&t);while(t--){scanf("%d",&x);if(isBad(x)==1)printf("-1\n");else{//查找下一个有效while(1){x++;if(isBad(x)==0){printf("%d\n",x);break;}}}}return 0;
}

3.50分

对于 50% 的数据，T≤1000，x≤10000。

纯暴力，极限情况，在x=10000中傻傻找约数,1,2,3,......,9999,10000的方式，查找10000次，再对约数进行判定，约数中数字是否含有7(极限是每个约数5次)，约数是否是7的倍数(极限是每个约数1次)，故此时对于每个极限计算次数是10000*(5+1)=60000，这是找一个数的情况，在x≤10000中，对应最多找数的情况，要编写代码测试，之后，才知道，预计下一个符合条件的数字间隔最大在11左右。因极限情况T=1000，总次数是60000*11*1000=6.6*10^8，超时不可避免。

纯暴力，极限情况，改进在x=10000约数,1,2,3,......,9999,10000的方式，按1,2,3,......,sqrt(100000)查找100次，再对约数进行判定，约数中数字是否含有7(极限是每个约数5次)，约数是否是7的倍数(极限是每个约数1次)，因找到一个约数，另一个约数也就找到了,故此时对于每个极限计算次数是2*100*(5+1)=1200，这是找一个数的情况，在x≤10000中，对应最多找数的情况，要编写代码测试，之后，才知道，预计下一个符合条件的数字间隔最大在11左右。因极限情况T=1000，总次数是1200*11*1000=1.32*10^7，预计处于超时，或不超时的临界状态。

70分代码如下：

#include <bits/stdc++.h>
using namespace std;
bool find7(int a){//判断数a是否被7整除,是否某位上包含7 if(a%7==0)return 1;while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
bool isBad(int x){//判断x中所有因数是否包含7 int a,b,c;b=sqrt(x);for(a=1;a<=b;a++){if(x%a==0){//a是约数 c=x/a;//c也是约数 if(find7(a)==1||find7(c)==1){break;} }}if(a==b+1)return 0;//x中不包含7 else return 1;//x中包含有7 
}
int main(){int t,x,a,b;scanf("%d",&t);while(t--){scanf("%d",&x);if(isBad(x)==1)printf("-1\n");else{//查找下一个有效while(1){x++;if(isBad(x)==0){printf("%d\n",x);break;}}}}return 0;
}

4.70分

对于 70% 的数据，T≤10000，x≤2×10^5。

纯暴力，极限情况，改进在x=200000，约数,1,2,3,......,199999,2*100000的方式，按1,2,3,......,sqrt(200000)查找447次，再对约数进行判定，约数中数字是否含有7(极限是每个约数5次)，约数是否是7的倍数(极限是每个约数1次)，因找到一个约数，另一个约数也就找到了,故此时对于每个极限计算次数是2*447*(6+1)=6258，这是找一个数的情况，在x≤200000中，对应最多找数的情况，要编写代码测试，之后，才知道，预计下一个符合条件的数字间隔最大在11左右。因极限情况T=10000，总次数是6258*11*10000=688380000=6.9*10^8，预计处于超时状态。

怎么改进，联想到桶排序，将2*10^5中的数据全部标记，这样就与查询次数无关了。但是每个数据都进行标记,极限情况，在x=200000，约数,1,2,3,......,199999,2*100000的方式，按1,2,3,......,sqrt(200000)查找447次，再对约数进行判定，约数中数字是否含有7(极限是每个约数5次)，约数是否是7的倍数(极限是每个约数1次)，因找到一个约数，另一个约数也就找到了,故此时对于每个极限计算次数是2*447*(6+1)=6258，这是找一个数的情况，在x≤200000中，最多有200000个数据。总次数是6258**200000=1.2516*10^9，超时了，在查找过程中，效率太低，有太多的重复。

该思路在测试大样例时，有太多的遗漏，那就作为脚印留下，读者可以跳过(如何提高效率，这时，线性筛素数浮现出来，把因数是7的数据标记出来，把某位上数据是7的数据标记出来，再由这两种数据派生出来的数据，继续标记出来。类似愚公移山，子又生孙，孙又生子......。因数是7的数据好标记，在生成合数时，就标记出来，那某位上数据是7时，如何标记，考虑了一下，在生成合数时，判断，并标记。x=200000，最多计算5次，200000个数据，最多计算次数200000*5=1*10^6，稳过70分。想的时候是这样，编码的时候，发现标记7*其他数据生成的新数据是，就已包含了上述两种情况，所以，200000个数据，最多计算次数200000*1=2*10^5.

线性筛素数有些模糊了，不过，好在当时学习时，是手动模拟过找出100里面的25个素数，磕磕碰碰，还是能编写出来。

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

一旦上面的25个素数找出来了，也就意味素数筛，编写成功了。

在测试过程中，发现，包含7的素数也要筛出来，因素数的数量不多，最大值很大时，通常不到最大值的十分之一，故算法的时间复杂度还是O(n).)

该思路在实际操作过程中，还是有数据的遗漏，决定删除(如何提高效率，这时，线性筛素数浮现出来，把因数是7的数据标记出来，把某位上数据是7的数据标记出来，生成新的数时，判定数位上是否包含7，是否能整除前面标记出因数是7或数位上是7的数。x=200000时,最多的数大约需要计算次数,数位上是6次，找因数是sqrt(200000)=447次，总的是6+447=453次，考虑到因数是7或数位上是7的数比较空洞，实际计算次数在50次左右，总的计算次数50*200000=10^7，介于超时与不超时间，还是有一定风险。

线性筛素数有些模糊了，不过，好在当时学习时，是手动模拟过找出100里面的25个素数，磕磕碰碰，还是能编写出来。

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

一旦上面的25个素数找出来了，也就意味素数筛，编写成功了。

在测试过程中，发现，包含7的素数也要筛出来，因素数的数量不多，最大值很大时，通常不到最大值的十分之一，故算法的时间复杂度还是O(n).)

很遗憾，提交，只有50分。)

50分代码如下：

#include <bits/stdc++.h>
#define maxn 210010 
using namespace std;
int prime[maxn/10],tot=0,d[maxn],seven[maxn/10],cnt=0; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void linear(int x){//线性筛素数 int i,j,k;for(i=2;i<=x;i++){if(d[i]==0){prime[++tot]=i;if(find7(i)==1)d[i]=2,seven[++cnt]=i;//素数中包含7的标记 }for(j=1;j<=tot&&i*prime[j]<=x;j++){if(d[i]==2||d[prime[j]]==2||find7(i*prime[j])==1)d[i*prime[j]]=2;//子又生孙,孙又生子else{for(k=1;k<=cnt&&seven[k]*seven[k]<=i*prime[j];k++)if(i*prime[j]%seven[k]==0){//判别当前数据是否包含7的内容 d[i*prime[j]]=2;break;}if(d[i*prime[j]]==0)d[i*prime[j]]=1;}  }}
} 
int main(){int t,x,a,b;linear(210000);scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==2)printf("-1\n");else{x++;//下一个数据 while(d[x]==2)x++;printf("%d\n",x);}}return 0;
}

猜测是数据溢出，加了long long后，还是50分代码如下：

#include <bits/stdc++.h>
#define maxn 210010 
using namespace std;
int prime[maxn/10],tot=0,d[maxn],seven[maxn/10],cnt=0; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void linear(int x){//线性筛素数 int i,j,k;for(i=2;i<=x;i++){if(d[i]==0){prime[++tot]=i;if(find7(i)==1)d[i]=2,seven[++cnt]=i;//素数中包含7的标记 }for(j=1;j<=tot&&i*prime[j]<=x;j++){if(d[i]==2||d[prime[j]]==2||find7(i*prime[j])==1)d[i*prime[j]]=2;//子又生孙,孙又生子else{for(k=1;k<=cnt&&(long long)seven[k]*seven[k]<=i*prime[j];k++)if(i*prime[j]%seven[k]==0){//判别当前数据是否包含7的内容 d[i*prime[j]]=2;break;}if(d[i*prime[j]]==0)d[i*prime[j]]=1;}  }}
} 
int main(){int t,x,a,b;linear(210000);scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==2)printf("-1\n");else{x++;//下一个数据 while(d[x]==2)x++;printf("%d\n",x);}}return 0;
}

决定采用另一种形式的筛法，发现一个有7的数据，马上，将之后的倍数打上标记，直到最大值。统计后，发现x<=210000里有179271个含7的数据，在x<=210000生成这些数据，需要562576次，70分，稳过。

以下为统计代码：

#include <bits/stdc++.h>
#define maxn 210010 
using namespace std;
int d[maxn]; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=1;i<=x;i++){if(find7(i)==1){for(j=1;i*j<=x;j++)d[i*j]=7,tot++;//统计总运行次数 }} printf("%d\n",tot);
} 
int main(){int t,x,a,b,cnt=0;shaker(210000);for(int i=1;i<=210000;i++)if(d[i]==7)cnt++;printf("%d\n",cnt);//统计生成含7的有效数据个数 scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==7)printf("-1\n");else{x++;//下一个数据 while(d[x]==7)x++;printf("%d\n",x);}}return 0;
}

以下为70分代码：

#include <bits/stdc++.h>
#define maxn 210010 
using namespace std;
int d[maxn]; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=1;i<=x;i++){if(find7(i)==1){for(j=1;i*j<=x;j++)d[i*j]=7;}} 
} 
int main(){int t,x,a,b;shaker(210000);scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==7)printf("-1\n");else{x++;//下一个数据 while(d[x]==7)x++;printf("%d\n",x);}}return 0;
}

5.100分

对于100% 的数据，T≤2×10^5，x≤10^7。

决定采用另一种形式的筛法，发现一个有7的数据，马上，将之后的倍数打上标记，直到最大值。统计后，发现x<=10001000里有9237439个含7的数据，在x<=10001000生成这些数据，需要44890674次，提交是100分，还是超时0分，胆颤心惊。

以下为统计代码：

#include <bits/stdc++.h>
#define maxn 10001010 
using namespace std;
int d[maxn]; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=1;i<=x;i++){if(find7(i)==1){for(j=1;i*j<=x;j++)d[i*j]=7,tot++;//统计总运行次数 }} printf("%d\n",tot);
} 
int main(){int t,x,a,b,cnt=0;shaker(10001000);for(int i=1;i<=10001000;i++)if(d[i]==7)cnt++;printf("%d\n",cnt);//统计生成含7的有效数据个数 scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==7)printf("-1\n");else{x++;//下一个数据 while(d[x]==7)x++;printf("%d\n",x);}}return 0;
}

以下为70分代码：

#include <bits/stdc++.h>
#define maxn 10001010 
using namespace std;
int d[maxn]; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=1;i<=x;i++){if(find7(i)==1){for(j=1;i*j<=x;j++)d[i*j]=7,tot++;//统计总运行次数 }} printf("%d\n",tot);
} 
int main(){int t,x,a,b,cnt=0;shaker(10001000);for(int i=1;i<=10001000;i++)if(d[i]==7)cnt++;printf("%d\n",cnt);//统计生成含7的有效数据个数 scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==7)printf("-1\n");else{x++;//下一个数据 while(d[x]==7)x++;printf("%d\n",x);}}return 0;
}

目前这种思路，比赛时，所有数据都超时，怎么办呢，稳妥的办法，就是比赛时存储x数据，找出最大值，根据最大值，进行筛法，以及开不定长数组vector。

以下为肯定能得70分的代码，不存在，小数据时，就超时的可能。

#include <bits/stdc++.h>
using namespace std;
vector<int> d;
int ask[200010],tot=0; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=0;i<=x;i++)d.push_back(0);//开拓不定长数组，最大长度 for(i=1;i<=x;i++){if(find7(i)==1){for(j=1;i*j<=x;j++)d[i*j]=7;}} 
} 
int main(){int t,x,a,b,mx=-1,T;scanf("%d",&t);T=t;while(T--){scanf("%d",&x);ask[++tot]=x,mx=max(mx,x);}shaker(mx+1000);tot=0;while(t--){x=ask[++tot];if(d[x]==7)printf("-1\n");else{x++;//下一个数据 while(d[x]==7)x++;printf("%d\n",x);}}return 0;
}

 继续想100分代码......

考虑记录中间生成含7的数据，再次遇到此类数据，就不再派生了，这样，应能大大减少重复计算。

 

 70分代码如下：

#include <bits/stdc++.h>
using namespace std;
vector<int> d;
int ask[200010],tot=0; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=0;i<=x;i++)d.push_back(0);//开拓不定长数组，最大长度 for(i=1;i<=x;i++){if(find7(i)==1&&d[i]==0){//避免重复计算 for(j=1;i*j<=x;j++)d[i*j]=7;}} 
} 
int main(){int t,x,a,b,mx=-1,T;scanf("%d",&t);T=t;while(T--){scanf("%d",&x);ask[++tot]=x,mx=max(mx,x);}shaker(mx+1000);tot=0;while(t--){x=ask[++tot];if(d[x]==7)printf("-1\n");else{x++;//下一个数据 while(d[x]==7)x++;printf("%d\n",x);}}return 0;
}

重新用定长数组，并改变d[i]==0的位置

#include <bits/stdc++.h>
#define maxn 10001010 
using namespace std;
int d[maxn]; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=1;i<=x;i++){if(d[i]==0&&find7(i)==1){for(j=1;i*j<=x;j++)d[i*j]=7;}} 
} 
int main(){int t,x,a,b;shaker(10001000);scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==7)printf("-1\n");else{x++;//下一个数据 while(d[x]==7)x++;printf("%d\n",x);}}return 0;
}

计算次数代码如下：

tot=16751956
cnt=7203036

#include <bits/stdc++.h>
#define maxn 10001010 
using namespace std;
int d[maxn],cnt=0; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;cnt++;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=1;i<=x;i++){if(d[i]==0&&find7(i)==1){for(j=1;i*j<=x;j++)d[i*j]=7,tot++;}} printf("tot=%d\n",tot);
} 
int main(){int t,x,a,b;shaker(10001000);printf("cnt=%d\n",cnt);scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==7)printf("-1\n");else{x++;//下一个数据 while(d[x]==7)x++;printf("%d\n",x);}}return 0;
}

应该来说，此种算法已经走到黑了，100分拿不了了，怎么办，只能换算法了。

结果是优化，我们用 nx 数组（也就是 next 的缩写）来记录该数的下一个报的数是多少。在处理的时候，我们需要记录上一个报的数pos（position 的缩写，也就是没有标记的数）。如果i没有标记过也不含有数字 7，那么 nx[pos] 就是i，然后将 pos更新为 i。

100分代码如下：

空间计算:int 占4个字节,(10001010*4+10001010*4)/1024/1024= 76.3MB

#include <bits/stdc++.h>
#define maxn 10001010 
using namespace std;
int d[maxn],nx[maxn],pos=0; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j,tot=0;for(i=1;i<=x;i++){if(d[i]==0&&find7(i)==1){for(j=1;i*j<=x;j++)d[i*j]=7;}if(d[i]==0){//优化，直接记录有效的数据，链表的形式 nx[pos]=i;pos=i;}} 
} 
int main(){int t,x,a,b;shaker(10001000);scanf("%d",&t);while(t--){scanf("%d",&x);if(d[x]==7)printf("-1\n");else{printf("%d\n",nx[x]);//优化 }}return 0;
}

最稳妥的100分代码，不定长数组，链表优化。

#include <bits/stdc++.h>
using namespace std;
vector<int> d,nx;
int ask[200010],pos=0; 
bool find7(int a){//判断数a是否某位上包含7 while(a){//分析个,十,百,千,等位上数字 if(a%10==7)return 1;a/=10;}return 0;//与7无关. 
}
void shaker(int x){//筛子 int i,j;for(i=0;i<=x;i++)d.push_back(0),nx.push_back(0);//开拓不定长数组，最大长度 for(i=1;i<=x;i++){if(d[i]==0&&find7(i)==1){//避免重复计算 for(j=1;i*j<=x;j++)d[i*j]=7;}if(d[i]==0){nx[pos]=i;pos=i;}} 
} 
int main(){int t,x,a,b,mx=-1,T,tot=0;scanf("%d",&t);T=t;while(T--){scanf("%d",&x);ask[++tot]=x,mx=max(mx,x);}shaker(mx+1000);tot=0;while(t--){x=ask[++tot];if(d[x]==7)printf("-1\n");else{printf("%d\n",nx[x]);}}return 0;
}

这篇关于NOIP 2021 第一题 报数 number 游走在超时的边缘(不定长数组) 10分+30分+50分(纯暴力)+70分(约数范围缩到sqrt(x)之内 4倍2倍重复的筛法 )+100分(查找优化)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/548557。

相关文章

uniapp接入微信小程序原生代码配置方案（优化版）

uniapp接入微信小程序原生代码配置方案（优化版）

uniapp项目需要把微信小程序原生语法的功能代码嵌套过来，无需把原生代码转换为uniapp，可以配置拷贝的方式集成过来 1、拷贝代码包到src目录 2、vue.config.js中配置原生代码包直接拷贝到编译目录中 3、pages.json中配置分包目录，原生入口组件的路径 4、manifest.json中配置分包，使用原生组件 5、需要把原生代码包里的页面修改成组件的方
阅读更多...
【Altium】查找PCB上未连接的网络

【Altium】查找PCB上未连接的网络

【更多软件使用问题请点击亿道电子官方网站】 1、文档目标： PCB设计后期检查中找出没有连接的网络 应用场景：PCB设计后期，需要检查是否所有网络都已连接布线。虽然未连接的网络会有飞线显示，但是由于布线后期整板布线密度较高，虚连，断连的网络用肉眼难以轻易发现。用DRC检查也可以找出未连接的网络，如果PCB中DRC问题较多，查找起来就不是很方便。使用PCB Filter面板来达成目的相比DRC
阅读更多...
Python应用开发——30天学习Streamlit Python包进行APP的构建（9）

Python应用开发——30天学习Streamlit Python包进行APP的构建（9）

st.area_chart 显示区域图。 这是围绕 st.altair_chart 的语法糖。主要区别在于该命令使用数据自身的列和指数来计算图表的 Altair 规格。因此，在许多 "只需绘制此图 "的情况下，该命令更易于使用，但可定制性较差。 如果 st.area_chart 无法正确猜测数据规格，请尝试使用 st.altair_chart 指定所需的图表。 Function signa
阅读更多...
基于CTPN（tensorflow）+CRNN（pytorch）+CTC的不定长文本检测和识别

基于CTPN（tensorflow）+CRNN（pytorch）+CTC的不定长文本检测和识别

转发来源：https://swift.ctolib.com/ooooverflow-chinese-ocr.html chinese-ocr 基于CTPN（tensorflow）+CRNN（pytorch）+CTC的不定长文本检测和识别 环境部署 sh setup.sh 使用环境： python 3.6 + tensorflow 1.10 +pytorch 0.4.1 注：CPU环境
阅读更多...
LeetCode--220 存在重复元素 III

LeetCode--220 存在重复元素 III

题目 给定一个整数数组，判断数组中是否有两个不同的索引 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值最大为 t，并且 i 和 j 之间的差的绝对值最大为 ķ。 示例 示例 1:输入: nums = [1,2,3,1], k = 3, t = 0输出: true示例 2:输入: nums = [1,0,1,1], k = 1, t = 2输出: true示例
阅读更多...
LeetCode--217 存在重复元素

LeetCode--217 存在重复元素

题目 给定一个整数数组，判断是否存在重复元素。如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。 示例 示例 1:输入: [1,2,3,1]输出: true示例 2:输入: [1,2,3,4]输出: false示例 3:输入: [1,1,1,3,3,4,3,2,4,2]输出: true class Solution {p
阅读更多...
axios全局封装AbortController取消重复请求

axios全局封装AbortController取消重复请求

为什么？ 问题：为什么axios要配置AbortController？防抖节流不行吗？ 分析： 防抖节流本质上是用延时器来操作请求的。防抖是判断延时器是否存在，如果存在，清除延时器，重新开启一个延时器，只执行最后一次请求。节流呢，是判断延时器是否存在，如果存在，直接return掉，直到执行完这个延时器。事实上，这些体验感都不算友好，因为对于用户来说，得等一些时间，尤其是首次请求，不是那么流畅
阅读更多...
剑指offer（C++）--数组中只出现一次的数字

剑指offer（C++）--数组中只出现一次的数字

题目 一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。 class Solution {public:void FindNumsAppearOnce(vector<int> data,int* num1,int *num2) {int len = data.size();if(len<2)return;int one = 0;for(int i
阅读更多...
服务器雪崩的应对策略之----SQL优化

服务器雪崩的应对策略之----SQL优化

SQL语句的优化是数据库性能优化的重要方面，特别是在处理大规模数据或高频访问时。作为一个C++程序员，理解SQL优化不仅有助于编写高效的数据库操作代码，还能增强对系统性能瓶颈的整体把握。以下是详细的SQL语句优化技巧和策略： SQL优化 1. 选择合适的数据类型2. 使用索引3. 优化查询4. 范式化和反范式化5. 查询重写6. 使用缓存7. 优化数据库设计8. 分析和监控9. 调整配置1、
阅读更多...
Java中如何优化数据库查询性能？

Java中如何优化数据库查询性能？

Java中如何优化数据库查询性能？ 大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！今天我们将深入探讨在Java中如何优化数据库查询性能，这是提升应用程序响应速度和用户体验的关键技术。 优化数据库查询性能的重要性 在现代应用开发中，数据库查询是最常见的操作之一。随着数据量的增加和业务复杂度的提升，数据库查询的性能优化显得尤为重
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2