数学

做了一些数学题本来是想把这个专栏的做完了再汇总的但是明天要测试了，没时间了现在开始就先做个小的汇总吧..缺的今后补上好了

******1.先说素数筛法虽然说了很多次了。

素数求和问题

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 2

描述

现在给你N个数（0<N<1000），现在要求你写出一个程序，找出这N个数中的所有素数，并求和。

输入

第一行给出整数M(0<M<10)代表多少组测试数据
每组测试数据第一行给你N，代表该组测试数据的数量。
接下来的N个数为要测试的数据，每个数小于1000

输出

每组测试数据结果占一行，输出给出的测试数据的所有素数和

样例输入

3
5
1 2 3 4 5
8
11 12 13 14 15 16 17 18
10
21 22 23 24 25 26 27 28 29 30

样例输出

10
41
52

素数求和，这个就是找到你输入的一个数n吧，找到他之前的所有素数，加在一起就行了。我们可以事先把题中要求的测试数据以内的素数先存到一个数组里面，以后每次测试数据的时候只用把n之前的素数加到一起就行了，这个就先不上代码了，说到快速筛素数的时候在上代码。

素数距离问题

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 2

描述

现在给出你一些数，要求你写出一个程序，输出这些整数相邻最近的素数，并输出其相距长度。如果左右有等距离长度素数，则输出左侧的值及相应距离。
如果输入的整数本身就是素数，则输出该素数本身，距离输出0

输入

第一行给出测试数据组数N(0<N<=10000)
接下来的N行每行有一个整数M(0<M<1000000)，

输出

每行输出两个整数 A B.
其中A表示离相应测试数据最近的素数，B表示其间的距离。

样例输入

3
6
8
10

样例输出

5 1
7 1
11 1

素数距离这个思路就是先判断你输入的这个数是不是素数，根据题意如果你输入的这个数不是素数就由这个数向两边扩散查找最小距离的素数。

核心代码：

m是你输入的这个数，我们还要写一个判断是不是素数的函数，如果是返回1，不是返回0；len初始化为0，是用来判断你输入的m是不是素数，他旁边的数是不是素数还有就是记录距离你输入这个数的距离大小。if中的（m-len）>1是威力保证你像左边搜索的数是正数。**如果左右有等距离长度素数，则输出左侧的值及相应距离。这句话是怎么实现的呢？就在if和else判断语句里面了，每次先判断左边的一个距离的数是不是素数，再看右边的，不符合的情况下len++往后走。如果有等距离的了那就是先输出其左边的值。

while(1)

{

     if(m-len)>1&&su(m-len)

   { printf("%d %d\n",m-len,len);

      break;}

    else if(su(m+len))

  {printf("%d %d\n“，m+len,len);

   break}

    len++;

}

快速查找素数

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 3

描述

现在给你一个正整数N，要你快速的找出在2.....N这些数里面所有的素数。

输入

给出一个正整数数N(N<=2000000)
但N为0时结束程序。
测试数据不超过100组

输出

将2~N范围内所有的素数输出。两个数之间用空格隔开

样例输入

5
10
11
0

样例输出

2 3 5
2 3 5 7
2 3 5 7 11

快速查找素数是不是和第一个一样？这个不用把素数加在一起就需要输出就行了，但是你用第一种方法会超时！虽然已经事先把素数让在一个数组里面了，但是在时间上还是不能AC；

#include<stdio.h>
bool nosu[2000000];//这里有一个新知识bool变量，你可以用int然后将数组里面元素全   int main()                      部初始化为0就行了
{
   int n,i,j;
   for(i=2;i<=1414;++i)//1414是2000000是开平方
       if(!nosu[i])
        for(j=i*i;j<=2000000;j+=i) 
          nosu[j]=1;
while(scanf("%d",&n)&&n)
{

        for(i=2;i<=n;++i)//++i不会超时。
              if(!nosu[i])
                  {
                       printf("%d ",i);
                    }
          printf("\n");
    }
     return 0;
 
}  

这里要说的就是我数组里面是素数的值为0，不是素数的值为1，我们之前的不都是找的是素数吗，为什么现在是吧不是素数的找出来？因为非素数找的快，j=i*i;随着i的增加，j是由指数形式增加的，循环的次数越来越少，所以查找的速度快。输出的！（不是素数的数），输出素数。

最大素因子

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 2

描述

GreyAnts最近正在学习数论中的素数，但是现在他遇到了一个难题：给定一个整数n,要求我们求出n的最大素因子的序数,例如：2的序数是1,3的序数是2,5的序数是3，以此类推. 研究数论是需要很大的耐心的，为了惩罚那些没有耐心读完题目的童鞋，我们规定：1的最大素因子序数是0.

输入

有多组测试数据,每一行输入一个数字n.(0<n<=1000000)

输出

在接下来的一行，输出结果.

样例输入

2
3
4
5

样例输出

1
2
1
3

就是让你把一个数的最大的素数因子的序数算出来。

为什么这个跟我们求素数的代码有牵扯？你想想看，一个数的最大素因子

我们是怎么筛选素数的？每次把最小因子的倍数给排除掉。是这个思想吧。\

那最小因子是                  2，3，5，7，11，13....都是素数吧。

 对应在那一轮被删           1   2   3    4     5    6

我们只要找到你输入的数是在哪一轮循环中被筛掉的，所以在这里把被筛选下来的数吧循环次数的存到数组里面就行了。

#include<stdio.h>
#define M 1000000
int a[M]={0};
int main()
{
int i,j,n,m=0;
for(i=2;i<=M;i++)
{
  if(a[i]==0)//这里还要保证筛选的数是第一次加入筛选的
  {
  m++;
  for(j=i;j<=M;j+=i)//重点就在于j的值 
  a[j]=m;
  }
}


while(~scanf("%d",&n))
{
    printf("%d\n",a[n]);
}
return 0;
}

********2讲讲快速幂

   次方求模

时间限制：1000 ms  |  内存限制：65535 KB

难度：3

描述

求a的b次方对c取余的值

 

输入

第一行输入一个整数n表示测试数据的组数（n<100）
每组测试只有一行，其中有三个正整数a,b,c(1=<a,b,c<=1000000000)

输出

输出a的b次方对c取余之后的结果

样例输入

3
2 3 5
3 100 10
11 12345 12345

样例输出

3
1
10481

快速幂有二分求幂

例如求a^b

把b换为二进制加入b=11

11的二进制是1011

11=1*2^3+0*2^2+1*2^1+1*2^0

那么我们求把a^11=a^(2^0+2^1+2^3)

快速幂可以运用位运算这个工具/

二分求幂代码：

int pow(int a,int b)
{
     int r=1,base=a;
    while(b>0)
   {
        if(b&1) r*=base;
        base*=base;
        b/=2;
   }
  return r;
}

int pow(int a,int b)
{
	if(b==0)
	  return 1;
	if(b==1)
	return a;
	
	int t=pow(a,b/2);
	   t=t*t;
     if(b&1)
	   t=t*a;
	   
	return t;	
} 

这个题的代码

#include<stdio.h>
long long kuai(int a,int b,int c)
{
    long long t;
     if(b==0)
             return 1%c;
     else if(b==1)
              return a%c;   
     else
    { 
           t=kuai(a,b/2,c);
           t=t*t%c;
           if(b&1)//判断b为奇数的时候这里少乘了一次
          t=t*a%c;
   }
     return t;
}
int  main()
{
     int T,a,b,c;
    scanf("%d",&T);
    while(T--)
   {
    scanf("%d%d%d",&a,&b,&c);
     printf("%lld\n",kuai(a,b,c));
   }
return 0;
}

为什么每次都要对c取余？这是一个公式：

a^b%c=a%c^(b%c);

p次方求和

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 3

描述

一个很简单的问题，求 1^p+2^p+3^p+ …… +n^p 的和。

输入

第一行单独一个数字t表示测试数据组数。接下来会有t行数字，每行包括两个数字n,p，
输入保证0<n<=1000,0<=p<=1000。

输出

输出1^p+2^p+3^p+……+n^p对10003取余的结果，每个结果单独占一行。

样例输入

2
10 1
10 2

样例输出

55
385

p次方求和

为什么要用到快速幂?简单的从时间效率上就能体现的出。不再做解析了/

#include<stdio.h>//二分求幂 
int pow(int a,int b)
{
int r=1,base=a;
while(b!=0)
{
r=r*base;
base=base*base;
b/=2;
} 
return r;
}


int main()
{
int T,n,p;
long long sum;
scanf("%d,",&T);
while(T--)
{
sum=0;
scanf("%d%d",&n,&p);
if(p==0)
sum+=n;
else
{
for(int i=1;i<=n;i++)
sum+=pow(i,p);
}

printf("%lld\n",sum%10003);
}
return 0;
}

晕，这会oj机刷爆了进不去，暂时不能贴题了，我就把几个做题遇见次数多的总结下】

*******3是欧几里得算法了

   题目：数字整除NYOJ664

#include<stdio.h> 
#include<string.h>
int main()
{
     char str[1000];
    while(scanf("%s" ,str) && strcmp(str, "0"))
{
     int i, s=0;
     for(i=0; str[i]!='\0'; i++)
     s= (s*10 + (str[i]- '0')) % 17;
     if(s==0) printf("1\n");
     else printf("0\n");
}
return 0;
}

其实就是只要能被17整除就输出1否则输出0就行了，上面这代码用到了s= (s*10 + (str[i]- '0')) % 17;

九的余数

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 3

描述

现在给你一个自然数n，它的位数小于等于一百万，现在你要做的就是求出这个数整除九之后的余数。

输入

第一行有一个整数m(1<=m<=8),表示有m组测试数据；
随后m行每行有一个自然数n。

输出

输出n整除九之后的余数，每次输出占一行。

样例输入

3
4
5
465456541

样例输出

4
5
4

//这个好像还没有用到欧几里得算法。

这里用到的是取模，从高位取余

不能简单的直接对这个数对9取余，会牵扯到大数的问题‘

利用到了9的特性
#include<stdio.h>
#include<string.h>
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
int i,len;
char a[100010];
scanf("%s",a);
len=strlen(a);
for(i=0;i<len;i++)
{
a[i]=a[i]-'0';
if(a[i]>=9)
a[i]=a[i]%9;
a[i+1]=a[i+1]+a[i]; 
//printf("len=%d ",strlen(a));在用到数组a是有要用她的长度，要事先把长度存起来
//在运行过程中在改变！ 
}
printf("%d\n",a[i-1]);

}
return 0;
} 

求余数

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 3

描述

现在给你一个自然数n，它的位数小于等于一百万，现在你要做的就是求出这个数除10003之后的余数

输入

第一行有一个整数m(1<=m<=8),表示有m组测试数据；
随后m行每行有一个自然数n。

输出

输出n整除10003之后的余数，每次输出占一行。

样例输入

3
4
5
465456541

样例输出

4
5
6948

就是大数求余。

从高位开始求余把，把整除的数*10加上下一位的数继续求余，

就是我们阶乘的逆向问题。

 #include<stdio.h>
#define N 1000000
char a[N];
int main()
{
int T; 
scanf("%d",&T);
while(T--)
{
scanf("%s",a);
int i=0,r=0;
while(a[i]!='\0')
{
r=(r*10+(a[i]-'0'))%10003;
i++;
}
printf("%d\n",r);
}
return 0;
}    

一个简单的数学题

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 3

描述

zyc最近迷上了数学，一天，dj想出了一道数学题来难住他。算出1/n,但zyc一时答不上来希望大家能编程帮助他。

输入

第一行整数T，表示测试组数。后面T行，每行一个整数 n (1<=|n|<=10^5).

输出

输出1/n. (是循环小数的,只输出第一个循环节).

样例输入

4
2
3
7
168

样例输出

0.5
0.3
0.142857
0.005952380

这里在循环问题上怎么去只让他输出一次循环的呢？

就先放上一个数组记录之前的数，如果一样的话就跳出不在输出。

#include<stdio.h>
#define M 100010
#include<string.h>
int a[M],b[M];
int main()
{
    int T,n,s,len;
    scanf("%d",&T);
   while(T--)
   {
       memset(b,0,sizeof(b));
       scanf("%d",&n);
      if(n<0)
      {
         printf("-");
          n=-n;
      }

      if(n==1)
     {
          printf("1\n");
      }
     else 
    {
         s=1;
        b[s]=1;
         len=0;
            while(1)
          {    
                s=s*10;     //1/n就是拿1去除n，放进整除的数和取余的数
               a[len++]=s/n;
                s%=n;
                if(b[s]||s==0)break;//退出条件就是整除完毕和第一次循环完毕
                 b[s]=1;      // 把每一次得到一个数后就改变他下标的值。
                                                   //只有再次返回的时候才会遇到改变过的值。
             }
        printf("0.");
          for(int i=0;i<len;i++)
             printf("%d",a[i]);
           printf("\n");

     } 
   }
     return 0;
}

整数性质

时间限制： 500 ms  |  内存限制： 65535 KB

难度： 1

描述

我们知道，在数学中，对于任意两个正整数a和b，必定存在一对整数s、t使得sa+tb=gcd(a,b)。

输入

多组测试数据。
每组数据输入两个非负整数a和b且a+b>0且a不等于b。
其中0<=a,b<100000。

输出

输出满足条件的 s 和 t 。

样例输入

2 4
3 8
737 635

样例输出

1 0
3 -1
193 -224

欧几里徳算法扩展

aX+bY=gcd(a,b)=gcd(b,a%b) 

#include<stdio.h>
#include<stdlib.h>
int s,t,temp;
void egcd(int a,int b)
{
if(a==0)
{
s=0;
t=1;
}
else if(b==0)
{
s=1;
t=0;
}
else 
{
egcd(b,a%b);
temp=s;
s=t;
t=temp-a/b*t;

}
} 
int main()
{
int a,b;
while(~scanf("%d%d",&a,&b))
{
egcd(a,b);
printf("%d %d\n",s,t);
}
return 0;
}

月老的烦恼（1）

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 3

描述

月老最近遇到了一个很棘手的问题，就是“剩男”“剩女”急速增长，而自己这边又人手不足导致天天都得加班。现在需要你来帮助月老解决这个问题，牵红绳的规则很简单：每个男生都一个编号n（1<=n<=500000）,编号n的因数之和就是要牵线的女生的编号。

如20的因子是：1,2,4,5,10；

 

输入

输入数据的第一行是一个数字T(1<=T<=500000),它表明测试数据的组数.然后是T组测试数据,每组测试数据只有一个数字N(1<=N<=500000).

输出

对于每组测试数据,请输出一个代表输入编号N男生的另一半的编号.

样例输入

3
2
10
12

样例输出

1
8
16

//打表新技能。

#include<stdio.h>
#define M 500000
long long sum[500005]; 
int main()
{
    int i,j;
    for(i=1;i<=M;i++)
    {
      for(j=1;j*i<=M;j++)
      sum[j*i]+=i;
    }
     int t,n;
     scanf("%d",&t);
     while(t--)
     {
        scanf("%d",&n);
         printf("%lld\n",sum[n]-n); 
     }
     return 0;
} 

********解密明文

移位密码

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 0

描述

移位密码是最简单的一类代替密码，具体算法就是将字母表的字母右移k个位置（k<26），并对字母表长度作模运算。

现给你一串密文，全部由大写字母组成。已知加密过程为：将每个字母按照字母表的顺序右移k位。

加密函数：E(m)=(m+k)%q.

请破译出明文！

输入

输入包含多组测试数据（少于1000组）。
每组数据包含一个字符串和一个整数k（k<26），中间用空格隔开，字符串全部由大写字母组成，长度小于50，k表示向右移动的位数.

输出

输出每组密文所对应的明文，每组输出占一行。

样例输入

JMPWFZPV 1

样例输出

ILOVEYOU

不管是明文密文，只要找到原来的字符符合函数与现在的字符一样就行了

#include<stdio.h>
#include<string.h>
int main()
{
      char ch[55],ch1[55];
       int k,l,i;
      while(~scanf("%s",ch))
      {
         scanf("%d",&k);
        l=strlen(ch);
                for(i=0;i<l;i++)
                 {
                        for(int j=0;j<26;j++)
                         {
                              if((j+k)%26==ch[i]-'A')
                            {
                                   ch1[i]=j+'A';
                             }
                        }
               }
                     ch1[i]='\0';
                     puts(ch1);
       }

             return 0;
}

乘数密码

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 1

描述

乘数密码也是一种替换密码，其加密变换是将明文字母串逐位乘以密钥k并进行模运算，数学表达式如下：

E(m)=k*m mod q,   gcd(k,q)=1 (即k，q互素)。

当k与q互素时，明文字母加密成密文字母的关系为一一映射。

现有一经过乘法加密的密文，请破译出它的明文。

输入

输入包含多组数据,不超过1000组。
每组包含一个字符串和一个正整数k，字符串全部由大写字母组成，长度不超过50，k是与q互素的数,q=26，k<26。

输出

每组输出数据单独占一行，输出对应的明文。

样例输入

ILOVEYOU 3

样例输出

UVWHKIWY

#include<stdio.h>
#include<string.h>
int main()
{
      char a[55];
      int k,l,i,j;
   while(~scanf("%s",a))
  {
         scanf("%d",&k);
       l=strlen(a);
        for(i=0;i<l;i++)
       {
        for(j=0;j<26;j++)
          {
             if(k*j%26==a[i]-'A')
             {
             a[i]=j+'A';
              break;
              }
            
           }
       
        }
         puts(a);
 
    } 
  return 0;
}

仿射密码

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 1

描述

仿射密码是替换密码的另一个特例，可以看做是移位密码和乘数密码的结合。其加密变换如下：

E(m)=(k1*m+k2) mod q;(其中k1,k2为密钥，且0<k1,k2<q。k1和q是互素的)。

现已知一经过仿射加密的密文和密钥，请破译出它的明文。

输入

输入包含不超过1000组数据；
每组数据包含一个由大写字母组成的字符串和两个正整数k1，k2，字符串长度不超过50，0<k1,k2<q。

输出

每组输出占一行，输出对应的明文。

样例输入

ILOVEYOU 3 2

样例输出

CDEPSQEG

#include<stdio.h>
#include<string.h>
int main()
{
char a[55];
int k1,k2,i,j,l;
while(~scanf("%s",a))
{
scanf("%d%d",&k1,&k2);
l=strlen(a);
for(i=0;i<l;i++)
{
for(j=0;j<26;j++)
{
if((k1*j+k2)%26==a[i]-'A')
{
a[i]=j+'A';
break; 
}
}
}
puts(a);
}
return 0;
}

我排第几个

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 3

描述

现在有"abcdefghijkl”12个字符，将其所有的排列中按字典序排列，给出任意一种排列，说出这个排列在所有的排列中是第几小的？

输入

第一行有一个整数n（0<n<=10000）;
随后有n行，每行是一个排列；

输出

输出一个整数m，占一行，m表示排列是第几位；

样例输入

3
abcdefghijkl
hgebkflacdji
gfkedhjblcia

样例输出

1
302715242
260726926

#include<stdio.h>//康拓展开！！！！ 
long int fac[]={1,1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600};
long cantor(char *p,int n)
{
long int i,j,temp,num;
num=0;
for(i=0;i<n;i++)
{
temp=0;
for(j=i+1;j<n;j++)
{
if(p[j]<p[i])
temp++;
}
num+=fac[n-i-1]*temp;
}
return num+1;
}
int main()
{
int T;
char s[13];
scanf("%d",&T);
while(T--)
{
scanf("%s",s);
printf("%ld\n",cantor(s,12));
}
return 0;

}

mdd的烦恼

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 3

描述

今天mdd看到这么一段话：在数论，对正整数n，欧拉函数是少于或等于n的数中与n互质的数的数目。此函数以其首名研究者欧拉命名，它又称为Euler's totient function、φ函数、欧拉商数等。 例如φ(8)=4，因为1,3,5,7均和8互质。于是他想用计算机实现欧拉函数的功能，但是他又不想去写，你能帮帮他吗？

ps: 互质（relatively primeì）又叫互素。若N个整数的最大公因数是1，则称这N个整数互质。

输入

有多组测试数据组数小于1003，
每组测试数据有一个整数n(0<n<=65535^2+1).

输出

输出欧拉函数φ(n)的值。

样例输入

2
6
46

样例输出

1
2
22

欧拉函数

找互素的个数

int eular(int n)

{

int ret=1,i;

  for(i=2;i*i<=n;i++)

     {

            if（n/i==0)

               { n=n/i;

              ret*=i-1;

                while(n%i==0)

                  { n=n/i;

                   ret*=i;

                    }

         }

}

if（n>1) ret*=n-1;

        return ret;

}

#include<stdio.h>
int eular(int n)
{
     int r=1,i;
     for(i=2;i*i<=n;i++)
     {
          if(n%i==0)
              {
               n=n/i;
               r=r*(i-1);
                while(n%i==0)
                       {
                               n=n/i;
                               r*=i;
                         }
                }
     }
          if(n>1)
               r*=n-1;
          return r;
}
int main()
{
            int n;
          while(~scanf("%d",&n))
          {
           printf("%d\n",eular(n));
           }
return 0;
}