机试笔记

目录

 

1.基础知识

1.1常用函数

1.2 字符串

1.2.1字符串哈希

1.3 数据结构

1.4数论

1.4.1最大公约数

1.4.2素数

1.4.3扩展欧几里得算法及其衍生

1.4.4组合数

2.一些小的注意点

3 刷的题

递归数列

---

1.基础知识

1.1常用函数

1. double：fabs(double x) 绝对值
2. double：floor(double x) 向下取整
3. double：ceil(double x) 向上取整
4. double：round(double x) 四舍五入
5. pow,log,sin,cos,tan,acos,asin,atan,sqrt
6. sort priority_queue自定义优先级

7. bool operator<(interval a , interval b)
   {
       if(a.ed == b.ed) return a.st<b.st;
       return a.ed>b.ed;   //从小到大
   }
   bool cmp(interval a,interval b)
   {
       if(a.st==b.st)
           return a.ed<b.ed;
       return a.st<b.st;//从小到大
   
   }
   priority_queue<int,vector<int>,greater<int> >que3;//注意“>>”会被认为错误，  
                                                         //这是右移运算符，所以这里用空格号隔开  
       priority_queue<int,vector<int>,less<int> >que4;最大值优先,默认就是最大值优先

    

8. sscanf(str,"%d",&n)，把字符数组str的内容以"%d"的格式写到n中。
9. sprintf(str,"%d",n)，把n以"%d"的格式写到str中，就是把整数变成字符串
10. 生成随机数：添加头文件stdlib.h头文件与time.h头文件。
    在main函数开头加上
     

    srand((unsigned)time(NULL));

    这个语句将生成随机数的种子，然后在需要用到随机数的地方使用rand()函数。
     

    rand()%(b-a+1)+a;//表示生成范围为[a,b]内的随机数

    但是缺点是范围不能太大。

11. 文件读写：

    
    freopen("in.txt","r",stdin);//设置 cin scanf 这些输入流都从 a.in中读取
    freopen("out.txt","w",stdout);//设置 cout printf 这些输出流都输出到 a.out里面去

     

1.2 字符串

1. sscanf(str,”%d”,&n) 
   以固定字符串为输入源 从一个字符串中读进与指定格式相符的数据 str为char str[maxn].
   这里可以把任意“指向字符的指针”看成字符串，从该位置开始，知道字符“\0”。
   例如如果str="(11,LL)"，那么

   int v;
   sscanf(&str[1],"%d",&v); 

   v就是11。

2. strchr(str,',')返回字符串str中从左往右第一个字符“,”的指针，在上面的例子里，它返回的字符串就是“,LL)”

3. sprintf(str,”%d”,n)

1.2.1字符串哈希

1. 把字符串的A~Z视为0~25，这样就把26个大写字母对应到了26进制中，接着将二十六进制转换为十进制，而十进制为唯一的。

1.3 数据结构

1. 给定一棵包含2^d个结点的完全二叉树，如果把结点从上到下从左到右编号为1，2，3……，则结点k的左右子节点编号分别为2k和2k+1。
2. 欧拉道路/欧拉回路，即一笔画问题。
   性质：
   由于除了起点和终点外，其他点的进出次数应该相等，所以如果一个无向图是连通的，且最多只有两个奇点，则一定存在欧拉道路。如果有两个奇点，则必须从一个奇点出发另一个奇点终止；如果没有奇点，则可以从任意点出发，最终一定会回到该点（欧拉回路）
   打印欧拉道路：

   void euler(int u)
   {
       for(int v=0;v<n;v++)
           if(G[u][v]&&!vis[u][v])
           {
               vis[u][v]=vis[v][u]=1;//换成vis[u][v]就变成了有向图
               euler(v);
               printf("%d %d\n",u,v);
           }
   }

    

1.4数论

1.4.1最大公约数

1. 辗转相除法：gcd(a,b)=gcd(b,a%b); //注意如果a<b，那么swap(a,b)
2. 0和任意一个整数a的最大公约数都是a。（当作递归边界
3. 最小公倍数：ab/gcd(a,b)

1.4.2素数

1. 如果要求一个正整数N的因子个数，只需要对其质因子分解，得到各质因子pi的个数分别为e1,e2、……ek，于是N的因子个数为。原因是，对每个质因子pi都可以选择其出现0次、1次、...、ei次，共ei+1种，组合起来就是答案。由同样的原理可知，N的所有因子之和为

1.4.3扩展欧几里得算法及其衍生

解决的问题：给定两个非零整数a和b，求一组整数解(x,y)，使得ax+by=gcd(a,b)成立

1. 由欧几里得算法得，a*1+b*0=gcd成立，此时有x=1,y=0成立
2. 由公式可以得出，求一组解的方法：

   int exGCD(int a,int b,int &x,int &y)
   {
       if (b==0)
       {
           x=1;
           y=0;
           return a;    
       }
       int g=exGCD(b,a%b,x,y);
       int temp=x;
       x=y;
       y=temp-a/b*y;
       return g;
   }

   就可以通过下面的式子得到全部解，其中K为任意整数
   

3. 求解方程ax+by=c
   假设ax+by=gcd的一组解(x0,y0)，要求c%gcd=0，则全部解为：
   

4. 同余式ax=c(mod m)的求解
   同余式，对整数a、b、m来说，如果m整除a-b，即(a-b)%m==0，那么就说a与b模m同余，对应的同余式为a=b(mod m)，m称为同余式的模。
   ax=c(mod m)就是要求解(ax-c)%m=0，因此存在整数y，使得ax-c=my成立，移项并令y=-y得ax+my=c,要求c%gcd(a,m)=0，否则无解。同理得到：
   
   其中K=0,1,...gcd(a,m)-1

5. 逆元的求解，以及(b/a)%m的计算
   扩展欧几里得求逆元：条件：gcd(a,m)=1，即互质

   int inverse(int a,int m)
   {
       int x,y;
       int g=exgcd(a,m,x,y);
       return (x%m+m)%m;
   }

   费马小定理：设m是素数，a是任意整数且a%m!=0，则。则a模m的逆元为%m。

1.4.4组合数

1. 由得到求组合式的递推公式，复杂度O()：

   const int n=60;
   void calC(){
       for(int i=0;i<=n;i++)
       {
           res[i][0]=res[i][i]=1;
       }
       for(int i=2;i<=n;i++)
       {
           for(int j=0;j<=i/2;j++)
           {
               res[i][j]=res[i-1][j]+res[i-1][j-1];
               res[i][i-j]=res[i][j];
           }
       }
   }

2. 由定义式:

   int C(int n,int m,int p)
   {
       int ans=1;
       for(int i=1;i<=m;i++)
       {
           ans=ans*(n-m+i)%p;
           ans=ans*inverse(i,p)%p;//求i模p的逆元
       }
   }

    

---

2.一些小的注意点

1. arccos->acos()   pi=acos(-1)

2. 先序遍历：根左右

   中序遍历：左根右

   后序遍历：左右根

3. lower_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

   upper_bound( begin,end,num)：从数组的begin位置到end-1位置二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

4. 闰年：if (y%400==0 || (y%100 && y%4==0)) 

   普通闰年:能被4整除但不能被100整除的年份为普通闰年。（如2004年就是闰年，1999年不是闰年）；

   世纪闰年:能被400整除的为世纪闰年。（如2000年是世纪闰年，1900年不是世纪闰年）；

5. 子串是连续的。子序列是中的字符在给定字符串中是不一定连续的。

6. 多组数据不能直接while(1)，还是判断一下是否是EOF吧。

7. 数据大小：
    

   int	~
   long long	~
   double	~  实际精度15~16位

8. 太大的常数赋值给long long 需要在末尾加LL
9. double类型的数标准输出应该是printf("%f",x);
10. %md可以使不足m位的int型变量以m位进行右对齐输出，其中高位用空格补齐，如果本身长度超过m位，则保持原样。
    %0md就是用0补齐，%.mf是四舍六入五成双
11. log(1.0)=0，头文件是math.h，log即是以e为底数的，C语言中没有对任意底数求对数的函数，因此必须使用换底公式来将不是以自然对数为底的对数转换位以e为底的对数，即
12. 三角函数的参数应该是弧度制的，sin(pi*45/180)
13. strcmp(a,b)，比较字符串是否相同，如果相同则返回0
14. double类型比较大小，由于精度问题，范围控制在eps=1e-8，如果fabs(a-b)<eps，就是相等，依此类推a-b>eps，则是a大于b；a-b<-eps就是a小于b；a-b>-eps，就是a大于等于b；a-b<eps，就是a小于等于b。
15. 对于OJ来说一秒大概承受运算次数为~

---

3 刷的题

递归数列

题目描述

给定a0,a1,以及an=p*a(n-1) + q*a(n-2)中的p,q。这里n >= 2。 求第k个数对10000的模。

输入描述:

输入包括5个整数：a0、a1、p、q、k。

输出描述:

第k个数a(k)对10000的模。

示例1

输入

20 1 1 14 5

输出

8359

注意: 这里使用了矩阵快速幂来做，其实数据量不大不需要矩阵快速幂。注意矩阵快速幂的初始矩阵的构造以及不能用全为1的矩阵作为快速幂开始的矩阵（。

#include<stdio.h>
using namespace std;
const int mod = 10000;
int a0, a1;
int p, q, k;
struct mat
{
	int x11, x12, x21, x22;
};
mat matmul(mat &a, mat &b)
{
	mat c;
	c.x11 = (a.x11*b.x11%mod + a.x12*b.x21%mod) % mod;
	c.x12 = (a.x11*b.x12%mod + a.x12*b.x22%mod) % mod;
	c.x21 = (a.x21*b.x11%mod + a.x22*b.x21%mod) % mod;
	c.x22 = (a.x21*b.x12%mod + a.x22*b.x22%mod) % mod;
	return c;
}
mat pow(int k)
{
	mat a;
	a.x11 = p;
	a.x12 = q;
	a.x21 = 1;
	a.x22 = 0;
	mat ans = a; #原来就是这里错了，把ans设为全1矩阵了。
	while (k)
	{
		if (k & 1)
			ans = matmul(a, ans);
		a = matmul(a, a);
		k >>= 1;
	}
	return ans;
}
int main()
{
	while (~scanf("%d%d%d%d%d", &a0, &a1, &p, &q, &k))
	{
        q=q%mod;
        p=p%mod;
		mat ans = pow(k-1);
		printf("%d\n", (ans.x21*a1%mod + ans.x22*a0%mod) % mod);
	}
}