整型数组处理算法（八）插入（+、-、空格）完成的等式：1 2 3 4 5 6 7 8 9=N[华为面试题]

2024-06-11 18:48
文章标签 算法 数组 面试题 华为 处理 完成 插入 空格 整型 等式

本文主要是介绍整型数组处理算法（八）插入（+、-、空格）完成的等式：1 2 3 4 5 6 7 8 9=N[华为面试题]，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

转载自

有一个未完成的等式：1 2 3 4 5 6 7 8 9=N

当给出整数N的具体值后，请你在2，3，4，5，6，7，8，9这8个数字的每一个前面，或插入运算符号“+”，或插入一个运算符号“-”，或不插入任何运算符号，使等式成立，并统计出能使等式成立的算式总数，若无解，则输出0。
例如：取N为108时，共能写出15个不同的等式，以下就是其中的二个算式：
1+23+4+56+7+8+9=108
123-45+6+7+8+9=108
输入一个数N

输出一个数，表示能使等式成立的算式总数。


方法一：

[cpp]  view plain copy
  1. #include "stdafx.h"  
  2. #include <iostream>  
  3. #include <string>  
  4. #include <fstream>  
  5. #include <sstream>  
  6. #include "stdio.h"  
  7.     using namespace std;  
  8. #define N 9   
  9. //把数字转换为字符串  
  10. string convertstrtoint(int j){  
  11.     stringstream tempstream;  
  12.     tempstream<<j;  
  13.     string i;  
  14.     tempstream>>i;  
  15.     tempstream.clear();  
  16.     tempstream.str("");  
  17.     return i;  
  18. }  
  19. void init(int*a,int num){  
  20.     int temp=10;  
  21.    
  22.     a[0]=1;  
  23.     for(int i=1;i<num;i++)  
  24.     {  
  25.         a[i]=temp;  
  26.         temp=temp*10;  
  27.     }  
  28. }  
  29. int garr[]={1,2,3,4,5,6,7,8,9};  
  30. int mulnumi[10];  
  31. //将数组中的数，组合成整数  
  32. int GetNumFromArr(int* b,int num)  
  33. {  
  34.     int tempsum=0;  
  35.     int tempnum=0;  
  36.    
  37.     for(int i=num-1;i>=0;i--)  
  38.     {  
  39.         tempnum=b[i]*mulnumi[num-i-1];  
  40.         tempsum+=tempnum;  
  41.     }  
  42.     return tempsum;  
  43. }  
  44.    
  45. void GetExpressResult(int* arr,int num,int expectval,int curval,int* pnum,string rstr)  
  46. {  
  47.    
  48.     int temp=0;  
  49.     for(int i=0;i<num;i++){  
  50.         temp=GetNumFromArr(arr,i+1);  
  51.         if(i+1==num)  
  52.         {  
  53.    
  54.             if(curval==temp)  
  55.             {  
  56.                 cout<<rstr<<"+"+convertstrtoint(temp)<<endl;  
  57.                 (*pnum)++;      
  58.                 return;  
  59.             }  
  60.             if(curval==-temp){  
  61.                 cout<<rstr<<"-"+convertstrtoint(temp)<<endl;  
  62.                 (*pnum)++;      
  63.                 return;  
  64.             }  
  65.             else  
  66.             {   
  67.                 //cout<<rstr<<endl;  
  68.                 return ;  
  69.             }  
  70.         }  
  71.         else if(i+1<num)  
  72.         {  
  73.             GetExpressResult(arr+1+i,num-1-i,expectval,curval-temp,pnum,rstr+"+"+convertstrtoint(temp));  
  74.             if(num<N)  
  75.                 GetExpressResult(arr+1+i,num-1-i,expectval,curval+temp,pnum,rstr+"-"+convertstrtoint(temp));  
  76.    
  77.         }  
  78.     }  
  79. }  
  80.    
  81. int _tmain(int argc, _TCHAR* argv[])  
  82. {  
  83.     init(mulnumi,10);  
  84.     int res=0;//存放有多少个表达式  
  85.     int *p=garr+N;  
  86.     GetExpressResult(garr,N,5,5,&res,string(""));  
  87.     cout<<"total:"<<res<<endl;  
  88.     getchar();  
  89.     return 0;  
  90. }  


方法二：

[cpp]  view plain copy
  1. #include <iostream>  
  2. #include <cmath>  
  3. using namespace std;  
  4.    
  5. int func (const char* str, int num);  
  6. bool calc (const char* result, int num);  
  7. void display(const char* result);  
  8.    
  9. int main()  
  10. {  
  11.     const char str[] = "123456789";  
  12.     int num;  
  13.     cout << "input num: ";  
  14.     cin >> num;  
  15.     cout << "result: " << func(str, num) << endl;  
  16.     return 0;  
  17. }  
  18.    
  19. int func(const char* str, int num)  
  20. {  
  21.     //初始化输出数组  
  22.     int len = strlen(str);  
  23.     char* result = new char[len*2];  
  24.     for (int i = 0; i < len; i++)  
  25.     {  
  26.         result[i*2] = str[i];  
  27.     }  
  28.     result[len*2-1] = '\0';  
  29.        
  30.     //模拟3进制的运算  
  31.     char key[3] = {' ', '+', '-'};  
  32.     int n = pow(3.0, len - 1);  
  33.     int ret = 0;  
  34.     for (int i = 0; i < n; i++)  
  35.     {  
  36.         //把i转换成3进制，计算每一位，转换成字符，填入字符串相应位置  
  37.         int pos = len * 2 - 3; //个位数填入位置  
  38.         int temp = i, mod;  
  39.         do  
  40.         {  
  41.             mod = temp % 3;  
  42.             temp /= 3;  
  43.             result[pos] = key[mod];  
  44.             pos -= 2;  
  45.         }while (temp > 0);  
  46.         //高位补0  
  47.         while (pos > 0)  
  48.         {  
  49.             result[pos] = key[0];  
  50.             pos -= 2;  
  51.         }  
  52.         if (calc(result, num)) //计算结果并输出  
  53.             ret++;  
  54.     }  
  55.    
  56.     delete[] result;  
  57.     return ret;  
  58. }  
  59.    
  60. bool calc(const char* result, int num)  
  61. {  
  62.     int sum = 0, sign = 1, i = 0;  
  63.     int temp = 0;  
  64.     while (result[i] != '\0')  
  65.     {  
  66.         if (result[i] == ' ')  
  67.         {  
  68.             temp *= 10;  
  69.         }  
  70.         else if(result[i] == '+' || result[i] == '-')  
  71.         {  
  72.             sign = (result[i] == '+') ? 1 : -1;  
  73.             sum += temp;  
  74.             temp = 0;  
  75.         }  
  76.         else  
  77.         {  
  78.             temp += sign * (result[i] - '0');  
  79.         }  
  80.         i++;  
  81.     }  
  82.     sum += temp;  
  83.     if (sum == num)  
  84.     {  
  85.         display(result);   //输出结果  
  86.         return true;  
  87.     }  
  88.     else  
  89.         return false;  
  90. }  
  91.    
  92. void display(const char* result)  
  93. {  
  94.     for (int i = 0; i < strlen(result); i++)  
  95.         if (result[i] != ' ')  
  96.             cout << result[i];  
  97.     cout << endl;  
  98. }  

方法三：

[cpp]  view plain copy
  1. #include <stdio.h>  
  2.    
  3. /*返回两个数合并的情况*/  
  4. int HeBin(int arry[],int i,int j)  
  5. {  
  6.     int num=0;  
  7.     for(;i<=j;i++)  
  8.     {  
  9.         num = num*10 + arry[i];  
  10.     }  
  11.     return num;  
  12. }  
  13. //a为装载1~9的数组，n为当前数组所用到的数字顺序 ,g为输入的值  
  14. int Digui(int a[],int n,int g)  
  15. {  
  16.     static int sum1=0;  
  17.     int i=n;  
  18.     if(n > 0)  
  19.     {  
  20.         for(i = n;i >=0;i--)  
  21.         {  
  22.             if(i != 0)  
  23.             {  
  24.                 Digui(a,i-1,g-HeBin(a,i,n));        //数字合并加减的情况  
  25.                 Digui(a,i-1,g+HeBin(a,i,n));  
  26.             }else  
  27.             {  
  28.                 if(g - HeBin(a,0,n) == 0)  
  29.                 {  
  30.                 //    printf("%d - %d (0 , %d)\n",g,HeBin(a,0,n),n);  
  31.                     sum1++;        //符合条件的情况时，sum1加一  
  32.                 }  
  33.                 return sum1;  
  34.             }  
  35.         }  
  36.         Digui(a,n-1,g-a[i]);    //单个数字的加减的情况  
  37.         Digui(a,n-1,g+a[i]);  
  38.    
  39.     }else if(n == 0)  
  40.     {  
  41.         if(0 == g - a[n])  
  42.             sum1++;    //符号情况时加一  
  43.     }  
  44.     return sum1;  
  45. }  
  46.    
  47. int main()  
  48. {  
  49.     int a[] = {1,2,3,4,5,6,7,8,9};  
  50.     int goal;  
  51.     while(1 != (scanf("%d",&goal)));  
  52.     goal = Digui(a,8,goal);  
  53.     printf("%d\n",goal);  
  54.     return 0;  
  55. }  

方法四：

[cpp]  view plain copy
  1. /*--------------------------------------- 
  2. 函数型计算器(VC++6.0,Win32 Console)程序由 yu_hua 于2007-07-27设计完成 
  3. 功能： 
  4. 目前提供了10多个常用数学函数: 
  5.     ⑴正弦sin 
  6.     ⑵余弦cos 
  7.     ⑶正切tan 
  8.     ⑷开平方sqrt 
  9.     ⑸反正弦arcsin 
  10.     ⑹反余弦arccos 
  11.     ⑺反正切arctan 
  12.     ⑻常用对数lg 
  13.     ⑼自然对数ln 
  14.     ⑽ｅ指数exp 
  15.     ⑾乘幂函数∧ 
  16. 用法： 
  17. 如果要求2的32次幂，可以打入2^32<回车> 
  18. 如果要求30度角的正切可键入tan(Pi/6)<回车> 
  19. 注意不能打入：tan(30)<Enter> 
  20. 如果要求1.23弧度的正弦，有几种方法都有效： 
  21. sin(1.23)<Enter> 
  22. sin 1.23 <Enter> 
  23. sin1.23  <Enter> 
  24. 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 
  25. 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 
  26. 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 
  27. 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 
  28. 另外函数名前面如果是数字,那么自动认为二者相乘. 
  29. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 
  30. 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 
  31. 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 
  32. 此外，本计算器提供了圆周率 Pi键入字母时不区分大小写,以方便使用。 
  33. ----------------------------------------*/  
  34. #include <iostream>  
  35. #include <iomanip>  
  36. #include <cstdlib>  
  37. #include <cstring>  
  38. #include <cctype>  
  39. #include <cmath>  
  40. #include <stdio.h>  
  41. #include <string.h>  
  42. #include <windows.h>  
  43. using namespace std;  
  44. const char Tab=0x9;  
  45. const int  DIGIT=1;  
  46. const int MAXLEN=16384;  
  47. char s[MAXLEN],*endss;  
  48. int pcs=15;  
  49. double fun(double x,char op[],int *iop) {  
  50.     while (op[*iop-1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter>  
  51.         switch (op[*iop-1]) {  
  52.         case  7: x=sin(x);  (*iop)--;break;  
  53.         case  8: x=cos(x);  (*iop)--;break;  
  54.         case  9: x=tan(x);  (*iop)--;break;  
  55.         case 10: x=sqrt(x); (*iop)--;break;  
  56.         case 11: x=asin(x); (*iop)--;break;  
  57.         case 12: x=acos(x); (*iop)--;break;  
  58.         case 13: x=atan(x); (*iop)--;break;  
  59.         case 14: x=log10(x);(*iop)--;break;  
  60.         case 15: x=log(x);  (*iop)--;break;  
  61.         case 16: x=exp(x);  (*iop)--;break;  
  62.         }  
  63.     return x;  
  64. }  
  65. double calc(char *expr,char **addr) {  
  66.     static int deep; //递归深度  
  67.     static char *fname[]={ "sin","cos","tan","sqrt","arcsin","arccos","arctan","lg","ln","exp",NULL};  
  68.     double ST[10]={0.0}; //数字栈  
  69.     char op[10]={'+'}; //运算符栈  
  70.     char c,*rexp,*pp,*pf;  
  71.     int ist=1,iop=1,last,i;  
  72.     if (!deep) {  
  73.         pp=pf=expr;  
  74.         do {  
  75.             c = *pp++;  
  76.             if (c!=' '&& c!=Tab)  
  77.                 *pf++ = c;  
  78.         } while (c!='\0');  
  79.     }  
  80.     pp=expr;  
  81.     if ((c=*pp)=='-'||c=='+') {  
  82.         op[0] = c;  
  83.         pp++;  
  84.     }  
  85.     last = !DIGIT;  
  86.     while ((c=*pp)!='\0') {  
  87.         if (c=='(') {//左圆括弧  
  88.             deep++;  
  89.             ST[ist++]=calc(++pp,addr);  
  90.             deep--;  
  91.             ST[ist-1]=fun(ST[ist-1],op,&iop);  
  92.             pp = *addr;  
  93.             last = DIGIT;  
  94.             if (*pp == '('||isalpha(*pp) && strnicmp(pp,"Pi",2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法  
  95.                 op[iop++]='*';  
  96.                 last = !DIGIT;  
  97.                 c = op[--iop];  
  98.                 goto operate ;  
  99.             }  
  100.         }  
  101.         else if (c==')') {//右圆括弧  
  102.             pp++;  
  103.             break;  
  104.         } else if (isalpha(c)) {  
  105.             if (!strnicmp(pp,"Pi",2)) {  
  106.                 if (last==DIGIT) {  
  107.                     cout<< "π左侧遇）" <<endl;exit(1);  
  108.                 }  
  109.                 ST[ist++]=3.14159265358979323846264338328;  
  110.                 ST[ist-1]=fun(ST[ist-1],op,&iop);  
  111.                 pp += 2;  
  112.                 last = DIGIT;  
  113.                 if (!strnicmp(pp,"Pi",2)) {  
  114.                     cout<< "两个π相连" <<endl;exit(2);  
  115.                 }  
  116.                 if (*pp=='(') {  
  117.                     cout<< "π右侧遇（" <<endl;exit(3);  
  118.                 }  
  119.             } else {  
  120.                 for (i=0; (pf=fname[i])!=NULL; i++)  
  121.                     if (!strnicmp(pp,pf,strlen(pf))) break;  
  122.                 if (pf!=NULL) {  
  123.                     op[iop++] = 07+i;  
  124.                     pp += strlen(pf);  
  125.                 } else {  
  126.                     cout<< "陌生函数名" <<endl;exit(4);  
  127.                 }  
  128.             }  
  129.         } else if (c=='+'||c=='-'||c=='*'||c=='/'||c=='^') {  
  130.             char cc;  
  131.             if (last != DIGIT) {  
  132.                 cout<< "运算符粘连" <<endl;exit(5);  
  133.             }  
  134.             pp++;  
  135.             if (c=='+'||c=='-') {  
  136.                 do {  
  137.                     cc = op[--iop];  
  138.                     --ist;  
  139.                     switch (cc) {  
  140.                     case '+':  ST[ist-1] += ST[ist];break;  
  141.                     case '-':  ST[ist-1] -= ST[ist];break;  
  142.                     case '*':  ST[ist-1] *= ST[ist];break;  
  143.                     case '/':  ST[ist-1] /= ST[ist];break;  
  144.                     case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;  
  145.                     }  
  146.                 } while (iop);  
  147.                 op[iop++] = c;  
  148.             } else if (c=='*'||c=='/') {  
  149. operate:        cc = op[iop-1];  
  150.                 if (cc=='+'||cc=='-') {  
  151.                     op[iop++] = c;  
  152.                 } else {  
  153.                     --ist;  
  154.                     op[iop-1] = c;  
  155.                     switch (cc) {  
  156.                     case '*':  ST[ist-1] *= ST[ist];break;  
  157.                     case '/':  ST[ist-1] /= ST[ist];break;  
  158.                     case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;  
  159.                     }  
  160.                 }  
  161.             } else {  
  162.                 cc = op[iop-1];  
  163.                 if (cc=='^') {  
  164.                     cout<< "乘幂符连用" <<endl;exit(6);  
  165.                 }  
  166.                 op[iop++] = c;  
  167.             }  
  168.             last = !DIGIT;  
  169.         } else {  
  170.             if (last == DIGIT) {  
  171.                 cout<< "两数字粘连" <<endl;exit(7);  
  172.             }  
  173.             ST[ist++]=strtod(pp,&rexp);  
  174.             ST[ist-1]=fun(ST[ist-1],op,&iop);  
  175.             if (pp == rexp) {  
  176.                 cout<< "非法字符" <<endl;exit(8);  
  177.             }  
  178.             pp = rexp;  
  179.             last = DIGIT;  
  180.             if (*pp == '('||isalpha(*pp)) {  
  181.                 op[iop++]='*';  
  182.                 last = !DIGIT;  
  183.                 c = op[--iop];  
  184.                 goto operate ;  
  185.             }  
  186.         }  
  187.     }  
  188.     *addr=pp;  
  189.     if (iop>=ist) {  
  190.         cout<< "表达式有误" <<endl;exit(9);  
  191.     }  
  192.     while (iop) {  
  193.         --ist;  
  194.         switch (op[--iop]) {  
  195.         case '+':  ST[ist-1] += ST[ist];break;  
  196.         case '-':  ST[ist-1] -= ST[ist];break;  
  197.         case '*':  ST[ist-1] *= ST[ist];break;  
  198.         case '/':  ST[ist-1] /= ST[ist];break;  
  199.         case '^':  ST[ist-1] = pow(ST[ist-1],ST[ist]);break;  
  200.         }  
  201.     }  
  202.     return ST[0];  
  203. }  
  204. int main(int argc,char **argv) {  
  205.     //1 2 3 4 5 6 7 8 9 ＝110 中间可以挿＋ － 或者不挿 如果1 2 不挿的话 就是12  
  206.     char op[4]=" +-";  
  207.     int g1;  
  208.     int g2;  
  209.     int g3;  
  210.     int g4;  
  211.     int g5;  
  212.     int g6;  
  213.     int g7;  
  214.     int g8;  
  215.    
  216.     for (g1=0;g1<3;g1++)  
  217.     for (g2=0;g2<3;g2++)  
  218.     for (g3=0;g3<3;g3++)  
  219.     for (g4=0;g4<3;g4++)  
  220.     for (g5=0;g5<3;g5++)  
  221.     for (g6=0;g6<3;g6++)  
  222.     for (g7=0;g7<3;g7++)  
  223.     for (g8=0;g8<3;g8++) {  
  224.         strcpy(s,"1 2 3 4 5 6 7 8 9");  
  225.         s[ 1]=op[g1];  
  226.         s[ 3]=op[g2];  
  227.         s[ 5]=op[g3];  
  228.         s[ 7]=op[g4];  
  229.         s[ 9]=op[g5];  
  230.         s[11]=op[g6];  
  231.         s[13]=op[g7];  
  232.         s[15]=op[g8];  
  233.         if (110.0==calc(s,&endss)) printf("%s=110\n",s);  
  234.     }  
  235.     /* 
  236.     if (argc<=1) { 
  237.         if (GetConsoleOutputCP()!=936) system("chcp 936>NUL");//中文代码页 
  238.         cout << "计算函数表达式的值。"<<endl<<"支持(),+,-,*,/,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp"<<endl; 
  239.         while (1) { 
  240.             cout << "请输入表达式："; 
  241.             gets(s); 
  242.             if (s[0]==0) break;// 
  243.             cout << s <<"="; 
  244.             cout << setprecision(15) << calc(s,&endss) << endl; 
  245.         } 
  246.     } else { 
  247.         strncpy(s,argv[1],MAXLEN-1);s[MAXLEN-1]=0; 
  248.         if (argc>=3) { 
  249.             pcs=atoi(argv[2]); 
  250.             if (pcs<0||15<pcs) pcs=15; 
  251.             printf("%.*lf\n",pcs,calc(s,&endss)); 
  252.         } else { 
  253.             printf("%.15lg\n",calc(s,&endss)); 
  254.         } 
  255.     } 
  256.     */  
  257.     return 0;  
  258. }  
  259. //123+4+5+67-89=110  
  260. //123+4-5-6-7-8+9=110  
  261. //123-4+5-6-7+8-9=110  
  262. //123-4-5+6+7-8-9=110  
  263. //12+34+56+7-8+9=110  
  264. //12+3+45+67-8-9=110  
  265. //12-3+4-5+6+7+89=110  
  266. //1+234-56-78+9=110  
  267. //1+2+34+5+67-8+9=110  
  268. //1-2+3+45-6+78-9=110  

这篇关于整型数组处理算法（八）插入（+、-、空格）完成的等式：1 2 3 4 5 6 7 8 9=N[华为面试题]的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


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

相关文章

不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
无人叉车3d激光slam多房间建图定位异常处理方案-墙体画线地图切分方案

无人叉车3d激光slam多房间建图定位异常处理方案-墙体画线地图切分方案

墙体画线地图切分方案 针对问题：墙体两侧特征混淆误匹配，导致建图和定位偏差，表现为过门跳变、外月台走歪等 ·解决思路：预期的根治方案IGICP需要较长时间完成上线，先使用切分地图的工程化方案，即墙体两侧切分为不同地图，在某一侧只使用该侧地图进行定位 方案思路 切分原理：切分地图基于关键帧位置，而非点云。 理论基础：光照是直线的，一帧点云必定只能照射到墙的一侧，无法同时照到两侧实践考虑：关
阅读更多...
康拓展开（hash算法中会用到）

康拓展开（hash算法中会用到）

康拓展开是一个全排列到一个自然数的双射（也就是某个全排列与某个自然数一一对应） 公式： X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。（a[i]在不同应用中的含义不同）； 典型应用： 计算当前排列在所有由小到大全排列中的顺序，也就是说求当前排列是第
阅读更多...
csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

这是一道扩展欧几里得算法的简单应用题，这题是在湖南多校训练赛中队友ac的一道题，在比赛之后请教了队友，然后自己把它a掉 这也是自己独自做扩展欧几里得算法的题目 题意：把题意转变下就变成了：求d1*x - d2*y = f2 - f1的解,很明显用exgcd来解 下面介绍一下exgcd的一些知识点：求ax + by = c的解 一、首先求ax + by = gcd(a,b)的解 这个
阅读更多...
hdu2241（二分+合并数组）

hdu2241（二分+合并数组）

题意：判断是否存在a+b+c = x，a，b，c分别属于集合A,B,C 如果用暴力会超时，所以这里用到了数组合并，将b,c数组合并成d，d数组存的是b，c数组元素的和，然后对d数组进行二分就可以了 代码如下（附注释）： #include<iostream>#include<algorithm>#include<cstring>#include<stack>#include<que
阅读更多...
综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动，这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升：减少抖动，提高图像的清晰度和细节表现力，使得监控画面更加真实可信。 - 细节增强：在低光条件下，抖
阅读更多...
【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...
poj 3974 and hdu 3068 最长回文串的O（n）解法(Manacher算法)

poj 3974 and hdu 3068 最长回文串的O（n）解法(Manacher算法)

求一段字符串中的最长回文串。 因为数据量比较大，用原来的O（n^2）会爆。 小白上的O(n^2)解法代码：TLE啦~ #include<stdio.h>#include<string.h>const int Maxn = 1000000;char s[Maxn];int main(){char e[] = {"END"};while(scanf("%s", s) != EO
阅读更多...
hdu 1166 敌兵布阵（树状数组 or 线段树）

hdu 1166 敌兵布阵（树状数组 or 线段树）

题意是求一个线段的和，在线段上可以进行加减的修改。 树状数组的模板题。 代码： #include <stdio.h>#include <string.h>const int maxn = 50000 + 1;int c[maxn];int n;int lowbit(int x){return x & -x;}void add(int x, int num){while
阅读更多...
秋招最新大模型算法面试，熬夜都要肝完它

秋招最新大模型算法面试，熬夜都要肝完它

💥大家在面试大模型LLM这个板块的时候，不知道面试完会不会复盘、总结，做笔记的习惯，这份大模型算法岗面试八股笔记也帮助不少人拿到过offer ✨对于面试大模型算法工程师会有一定的帮助，都附有完整答案，熬夜也要看完，祝大家一臂之力 这份《大模型算法工程师面试题》已经上传CSDN，还有完整版的大模型 AI 学习资料，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2