2017蓝桥杯省赛模拟

1.算年龄
英国数学家德摩根出生于19世纪初叶（即18xx年）。
他年少时便很有才华。一次有人问他的年龄，他回答说：
“到了x的平方那年，我刚好是x岁”。
请你计算一下，德摩根到底出生在哪一年。

题中的年龄指的是周岁。

#include <cstdio>
#include <iostream>
using namespace std;
int main(){
	for(int i=1;i<=99;i++){
		if(i*i-i>=1800&&i*i-i<=1850){
			cout<<i*i-i<<endl;
		}
	}
	return 0;
}
//1806
//注意题中的x和此处的x不一样

2.猜算式
你一定还记得小学学习过的乘法计算过程，比如：
   273
x   15
------
  1365
  273
------
  4095
请你观察如下的乘法算式
    ***
x   ***
--------
    ***
   ***
  ***
--------
  *****
星号代表某位数字，注意这些星号中，
0~9中的每个数字都恰好用了2次。
(如因字体而产生对齐问题，请参看图p1.jpg)
请写出这个式子最终计算的结果，就是那个5位数是多少？

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int book[10];
inline void deal(int num){
	while(num){
		book[num%10]++;
		num/=10;
	}
}
int judge(){
	for(int i=0;i<10;i++){
		if(book[i]!=2){
			return 0;
		}
	}
	return 1;
}
int main(){
	int i,j;
	for(i=102;;i++){
		for(j=102;;j++){
			if(i*j>99999){
				break;
			}
			memset(book,0,sizeof(book));
			int n1=(j%10)*i;
			deal(n1);
			int n2=(j/10%10)*i;
			deal(n2);
			int n3=(j/100)*i;
			deal(n3);
			int n4=i*j;
			deal(n4);
			deal(i);
			deal(j);
			if(judge()){
				cout<<i*j<<endl;
				return 0;
			}
		}
	}
}
//40096

40096

#include <bits/stdc++.h>
using namespace std;
int n;
int a[6];
int pd(){
	int p[20]={0};
	for(int i=0;i<6;i++){
		int k=0;
		while(a[i]){
			p[a[i]%10]++;
			if(p[a[i]%10]>2)return 0;
			a[i]/=10;
			k++;
		}
		if(k<3) return 0;
	}
	return 1;
}
int main()
{
	for(int i=100;i<=999;i++)
		for(int j=100;j<=999;j++){
			a[0]=(j%10)*i;a[1]=(j/10%10)*i;  //a保存每一个状态的信息
			a[2]=(j/100)*i;a[3]=i*j;
			a[4]=i;a[5]=j;
			if(pd()){  //判断是否满足条件
				cout<<i*j<<" ";
			}
		}
	
	
	return 0;
} 

3.排列序数
X星系的某次考古活动发现了史前智能痕迹。
这是一些用来计数的符号，经过分析它的计数规律如下：
（为了表示方便，我们把这些奇怪的符号用a~q代替）
abcdefghijklmnopq 表示0
abcdefghijklmnoqp 表示1
abcdefghijklmnpoq 表示2
abcdefghijklmnpqo 表示3
abcdefghijklmnqop 表示4
abcdefghijklmnqpo 表示5
abcdefghijklmonpq 表示6
abcdefghijklmonqp 表示7
.....
在一处石头上刻的符号是：
bckfqlajhemgiodnp
请你计算出它表示的数字是多少？

//此题比较奇妙，肯定不能直接去用STL模板暴力，有点考察数学知识的意味......

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
long long re,f[18];
int book[26];
int Get(char c){
	int sum=0;
	for(int i='a';i<c;i++){
		if(!book[i]){
			sum++;
		}
	}
	book[c]=1;
	return sum;
}
int main(){
	string s="bckfqlajhemgiodnp";
	f[1]=1;
	re=0;
	for(int i=2;i<18;i++){
		f[i]=i*f[i-1];
	}
	for(int i=0;i<s.size();i++){
		re=re+Get(s[i])*f[17-i-1];
	}
	cout<<re<<endl;
	return 0;
}
//22952601027516

4.字符串比较
我们需要一个新的字符串比较函数compare(s1, s2).
对这个函数要求是：
1. 它返回一个整数，表示比较的结果。
2. 结果为正值，则前一个串大，为负值，后一个串大，否则，相同。
3. 结果的绝对值表示：在第几个字母处发现了两个串不等。
下面是代码实现。对题面的数据，结果为：
-3
2
5
仔细阅读源程序，填写划线位置缺少的代码。

int compare(const char* s1, const char* s2){
if(s1==NULL && s2==NULL) return 0;
if(s1==NULL) return -1;
if(s2==NULL) return 1;

if(*s1 == 0 && *s2== 0) return 0;
if(*s1 == 0) return -1;
if(*s2 == 0) return 1;

if(*s1<*s2) return -1;
if(*s1>*s2) return 1;

int t = compare(s1+1,s2+1);
if(t==0) return 0;

return __________________________; //填空位置
}
int main(){
printf("%d\n", compare("abc","abk"));
printf("%d\n", compare("abc","a"));
printf("%d\n", compare("abcde","abcda"));
return 0;
}

//t>0?t+1:t-1

5.还款计算
银行贷款的等额本息还款方法是：
每月还固定的金额，在约定的期数内正好还完（最后一个月可能会有微小的零头出入）。
比如说小明在银行贷款1万元。贷款年化利率为5%，贷款期限为24个月。
则银行会在每个月进行结算：
结算方法是：计算本金在本月产生的利息： 本金 x (年利率/12)
则本月本金结余为：本金 + 利息 - 每月固定还款额
计算结果会四舍五入到“分”。
经计算，此种情况下，固定还款额应为：438.71
这样，第一月结算时的本金余额是：
9602.96
第二个月结算：
9204.26
第三个月结算：
8803.9
....
最后一个月如果仍按固定额还款，则最后仍有0.11元的本金余额，
但如果调整固定还款额为438.72, 则最后一个月会多还了银行0.14元。
银行会选择最后本金结算绝对值最小的情况来设定 每月的固定还款额度。
如果有两种情况最后本金绝对值相同，则选择还款较少的那个方案。
本题的任务是已知年化利率，还款期数，求每月的固定还款额度。
假设小明贷款为1万元，即：初始本金=1万元。
年化利率的单位是百分之多少。
期数的单位为多少个月。
输入为2行，
第一行为一个小数r，表示年率是百分之几。(0<r<30)
第二行为一个整数n，表示还款期限。 (6<=n<=120)
要求输出为一个整数，表示每月还款额（单位是：分）
例如：
输入：
4.01
24
程序应该输出：
43429
再比如：
输入：
6.85
36
程序应该输出：
30809

//自己：

//答案按照 元 做的，自己按照 分 做的
#include <cstdio>
#include <cmath>
#include <iostream>
using namespace std;
void Change(int &total,double rate,int pay){
	double t=(double)total*(1+rate/100.0)-pay+0.5;
	total=(int)t;
}
int main(){
	double rate;
	int month;
	int total,count;
	int re=2000000,cnt=2000000,choice;//最后本金绝对值较小  还款较小 最后选择
	scanf("%lf%d",&rate,&month);
	rate/=12;
	for(int i=1000000/month;;i++){
		count=0;//当前选择最后的总金额
		total=1000000;//当前钱数
		for(int j=1;j<=month;j++){
			count+=i;
			Change(total,rate,i);
		}
		if((int)fabs(total)<re||count<cnt){
			re=(int)fabs(total);
			cnt=count;
			choice=i;
		}
		if(total<0){
			break;
		}
	}
	cout<<choice<<endl;
	return 0;
}

//答案：

#include <bits/stdc++.h>
using namespace std;
double r;
int n;
double sol(double x){
	int a=(x+0.005)*100;
	return a/100.0;
}
int main()
{
	cin>>r>>n;
	double money=10000.0/n;     //从最小开始枚举
	money=sol(money);           //精确到分 四舍五入
	double ans,minn=10000000;     //ans 答案  minn保存最近答案的数
	for(;1;money+=0.01){        //每次递增0.01
		double total=10000;     //初始化金钱
		for(int i=0;i<n;i++){     //算n个月过后还剩多少钱
			double lx=total*(0.01*r/12);
			total+=-money+lx;
			total=sol(total);
		}
		if(total<0){   //小于就退出
			if(fabs(total)<minn)
				ans=money;
			break;
		}
		ans=money;
	}
	cout<<(int)(ans*100)<<endl;
	return 0;
}

6.滑动解锁
滑动解锁是智能手机一项常用的功能。你需要在3x3的点阵上，从任意一个点开始，反复移动到一个尚未经过的"相邻"的点。这些划过的点所组成的有向折线，如果与预设的折线在图案、方向上都一致，那么手机将解锁。
所谓两个点“相邻”：当且仅当以这两个点为端点的线段上不存在尚未经过的点。
此外，许多手机都约定：这条折线还需要至少经过4个点。
为了描述方便，我们给这9个点从上到下、从左到右依次编号1-9。即如下排列：
1 2 3
4 5 6
7 8 9
那么1->2->3是非法的，因为长度不足。
1->3->2->4也是非法的，因为1->3穿过了尚未经过的点2。
2->4->1->3->6是合法的，因为1->3时点2已经被划过了。
某大神已经算出：一共有389112种不同的解锁方案。没有任何线索时，要想暴力解锁确实很难。
不过小Hi很好奇，他希望知道，当已经瞥视到一部分折线的情况下，有多少种不同的方案。
遗憾的是，小Hi看到的部分折线既不一定是连续的，也不知道方向。
例如看到1-2-3和4-5-6，
那么1->2->3->4->5->6，1->2->3->6->5->4, 3->2->1->6->5->4->8->9等都是可能的方案。
你的任务是编写程序，根据已经瞥到的零碎线段，求可能解锁方案的数目。
输入：
每个测试数据第一行是一个整数N(0 <= N <= 8)，代表小Hi看到的折线段数目。
以下N行每行包含两个整数 X 和 Y (1 <= X, Y <= 9)，代表小Hi看到点X和点Y是直接相连的。
输出：
对于每组数据输出合法的解锁方案数目。
例如：
输入：
8
1 2 2 3
3 4 4 5
5 6 6 7
7 8 8 9
程序应该输出：
2
再例如：
输入：
4
2 4
2 5
8 5
8 6
程序应该输出：
258
//待写......

7.风险度量
X星系的的防卫体系包含 n 个空间站。这 n 个空间站间有 m 条通信链路，构成通信网。
两个空间站间可能直接通信，也可能通过其它空间站中转。
对于两个站点x和y (x != y), 如果能找到一个站点z，使得：
当z被破坏后，x和y无法通信，则称z为关于x,y的关键站点。
显然，对于给定的两个站点，关于它们的关键点的个数越多，通信风险越大。
你的任务是：已知网络结构，求两站点之间的通信风险度，即：它们之间的关键点的个数。
输入数据第一行包含2个整数n(2 <= n <= 1000), m(0 <= m <= 2000),分别代表站点数，链路数。
空间站的编号从1到n。通信链路用其两端的站点编号表示。
接下来m行，每行两个整数 u,v (1 <= u, v <= n; u != v)代表一条链路。
最后1行，两个数u,v，代表被询问通信风险度的两个站点。
输出：一个整数，如果询问的两点不连通则输出-1.
例如：
用户输入：
7 6
1 3 2 3
3 4 3 5
4 5 5 6
1 6
则程序应该输出：
2

//割点

法一：

//此法常用于求整个图中的割点割桥，若图不连通，则对每个连通分量进行此算法
//对于此题，去处理两点间的割点有点麻烦
#include <cstdio>
#include <set>
#include <cstring>
#include <iostream>
using namespace std;
struct node{
	int to;
	int next;
}edge[2005];
int n,m,u,v,cnt,count,kill;
int head[1005],index[1005],pre[1005],book[1005];
set<int> s;
int dfs(int x){
	if(x==v){
		return 1;
	}
	for(int i=head[x];i;i=edge[i].next){
		if(!book[edge[i].to]&&edge[i].to!=kill){
			book[edge[i].to]=1;
			if(dfs(edge[i].to)){
				return 1;
			}
			book[edge[i].to]=0;
		}
	}
	return 0;
}
void cut(int x,int fa){
	int child=0;
	count++;
	index[x]=count;
	pre[x]=count;
	for(int i=head[x];i;i=edge[i].next){
		if(index[edge[i].to]&&edge[i].to!=fa){
			pre[x]=min(pre[x],index[edge[i].to]);
		}
		if(!index[edge[i].to]){
			cut(edge[i].to,x);
			child++;
			pre[x]=min(pre[x],pre[edge[i].to]);
            if(fa==-1&&child>1||fa!=-1&&pre[edge[i].to]>=index[x]){
			     s.insert(x);
		    } 
        }
    }
}
void Add(int x,int y){
	cnt++;
	edge[cnt].to=y;
	edge[cnt].next=head[x];
	head[x]=cnt;
}
int main(){
	int x,y,re=0;
	cin>>n>>m;
	s.clear();
	for(int i=1;i<=m;i++){
		cin>>x>>y;Add(x,y);
		Add(y,x);
	}
	cin>>u>>v;
	book[u]=1;
	kill=n+1;
	if(!dfs(u)){
		printf("-1\n");
		return 0;
	}else{
		set<int> ::iterator it;
		cut(u,-1);
		for(it=s.begin();it!=s.end();it++){
			if(*it==u||*it==v){
				continue;
			}
			memset(book,0,sizeof(book));
			kill=*it;
			book[u]=1;
			if(!dfs(u)){
				re++;
			}
		}
	}
	cout<<re<<endl;
	return 0;
}

//法二：
//求两点之间的割点，用深搜即可
//此办法拓展到两点间的割边也可以
#include <cstdio>
#include <queue>
#include <iostream>
using namespace std;
struct node{
	int to;
	int next;
}edge[2005];
int n,m,cnt,re,start,endss,flag,count;
int head[1005],path[1005],times[1005],book[1005];
void Add(int x,int y){
	cnt++;
	edge[cnt].to=y;
	edge[cnt].next=head[x];
	head[x]=cnt;
}
int dfs(int x,int step){
	path[step]=x;
	if(x==endss){
		flag=1;
		count++;
		for(int i=1;i<=step;i++){
			times[path[i]]++;
		}
	}
	for(int i=head[x];i;i=edge[i].next){
		if(!book[edge[i].to]){
			book[edge[i].to]=1;
			dfs(edge[i].to,step+1);
			book[edge[i].to]=0;
		}
	}
}
int main(){
	int x,y;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		scanf("%d%d",&x,&y);
		Add(x,y);
		Add(y,x);
	}
	scanf("%d%d",&start,&endss);
	book[start]=1;
	dfs(start,1);
	if(!flag){
		printf("-1\n");
	}
	else{
		for(int i=1;i<=n;i++){
			if(i!=start&&i!=endss&×[i]==count){
				re++;
			}
		}
		cout<<re<<endl;
	}
	return 0;
}

//法三：


//用并查集 求两点间的割点
#include <cstdio>
#include <iostream>
using namespace std;
int edge[2005][2];
int fa[1005];
int n,m;
int Get(int x){
	return fa[x]=(fa[x]==x?x:Get(fa[x]));
}
void Merge(int x,int y){
	int a=Get(x);
	int b=Get(y);
	if(a!=b){
		fa[b]=a;
	}
}
int main(){
	int u,v,count=0;
	cin>>n>>m;
	for(int i=0;i<m;i++){
		cin>>edge[i][0]>>edge[i][1];
	}
	cin>>u>>v;
	for(int i=1;i<=n;i++){
		fa[i]=i;
	}
	for(int i=0;i<m;i++){
		Merge(edge[i][0],edge[i][1]);
	}
	if(Get(u)!=Get(v)){
		cout<<-1<<endl;
		return 0;
	}
	for(int i=1;i<=n;i++){
		if(i==u||i==v){
			continue;
		}
		for(int j=1;j<=n;j++){
			fa[j]=j;
		}
		for(int j=0;j<m;j++){
			if(edge[j][0]!=i&&edge[j][1]!=i){
				Merge(edge[j][0],edge[j][1]);
			}
		}
		if(Get(u)!=Get(v)){
			count++;
		}
	}
	cout<<count<<endl;
	return 0;
}
//拓展：


//用并查集 求两点间的割边
#include <bits/stdc++.h>
using namespace std;
int n,m;
int s[2005][2];
int sum=0;
int fd[1005];
int find(int x){//并查集
	if(fd[x]==x) return x;
	return fd[x]=find(fd[x]);
}
int main(){
	cin>>n>>m;
	for(int i=0;i<m;i++)
		cin>>s[i][0]>>s[i][1];
	int k1,k2;
	cin>>k1>>k2;
	for(int i=0;i<m;i++){//枚举每一条边  然后去掉  然如果连通 就不是关键边
		for(int ii=1;ii<=n;ii++)fd[ii]=ii;
		for(int j=0;j<m;j++){
			if(i!=j){
				int a=find(s[j][0]);//并查集
				int b=find(s[j][1]);
				if(a!=b)
					fd[a]=b;
			}
		}
		int a=find(k1);
		int b=find(k2);//查看两个端点是否连通
		if(a!=b) sum++;
	}
	cout<<sum<<endl;
	return 0;
}