【思特奇杯·云上蓝桥-算法集训营】第二周

问题1 带分数

问题描述

100 可以表示为带分数的形式：100 = 3 + 69258 / 714。

还可以表示为：100 = 82 + 3546 / 197。

注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。

类似这样的带分数，100 有 11 种表示法。

输入格式

从标准输入读入一个正整数N (N<1000*1000)

输出格式

程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。

注意：不要求输出每个表示，只统计有多少表示法！

样例输入1

100

样例输出1

11

样例输入2

105

样例输出2

6

主要运用递归的思想，对1-9这九个数进行全排列，再筛选出其中符合的排列方式的种数。代码如下

#include <stdio.h>
void quanpl(int *,int ,int,int [],int );
void jiaohuan(int *,int *);
void jianyan(int *,int,int [],int );
int hecheng(int [],int);
void jy_fs(int *,int,int [],int );

int main(void)
{
	int n;
	scanf("%d",&n);
	int sm[9]={1,2,3,4,5,6,7,8,9};
	int bsf=0;
	quanpl(&bsf,0,9,sm,n);
	printf("%d\n",bsf);
	return 0;
}
void jy_fs(int *p_zs,int gs,int fs[],int m)
{
	int fmws;
	for(fmws=1;fmws<=gs-fmws;fmws++)
	{
		int fm=hecheng(fs,fmws),fz=hecheng(fs+fmws,gs-fmws);
		if(fz%fm==0)
		{
			*p_zs+=m==fz/fm;
		}
	}
}
int hecheng(int sm[],int ws)
{
	int shu = 0;
	do
	{
		shu *= 10;
		shu += *sm++;
	}
	while(--ws>0);
	return shu;
}
void jianyan(int *p_zs,int gs,int sm[],int n)
{
	int zsws;
	int shu;
	for(zsws=1;(shu=hecheng(sm,zsws))<n;zsws++)
	{
		jy_fs(p_zs,gs-zsws,sm+zsws,n-shu);
	}
}
void jiaohuan(int *p,int*q)
{
	int t=*p;
	*p=*q;
	*q=t;
}
void quanpl(int *p_zs,int dq,int gs,int sm[],int n)
{
	int h;
	for(h=dq;h<gs;h++)
	{
		jiaohuan(sm+dq,sm+h);
		quanpl(p_zs,dq+1,gs,sm,n);
		jiaohuan(sm+dq,sm+h);
	}
}

问题2 李白打酒

题目描述

话说大诗人李白，一生好饮。幸好他从不开车。

一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：

无事街上走，提壶去打酒。

逢店加一倍，遇花喝一斗。

这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。

请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的次序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。

答案为14，运用递归的思想。代码如下

#include <iostream>
using namespace std;
int cnt = 0;

void f(int shop, int flower, int wine)
{
    if(shop > 0)
        f(shop-1, flower, wine*2);
    if(flower > 0)
        f(shop, flower-1, wine-1);
    if(shop==0 && flower==0 && wine==1) 
        cnt += 1;
}

int main()
{
    f(5, 9, 2);
    cout << cnt << endl;
    return 0;
} 

 问题3 第39级台阶

题目描述：

    小明刚刚看完电影《第39级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是39级!

    站在台阶前，他突然又想着一个问题：

    如果我每一步只能迈上1个或2个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完39级台阶，有多少种不同的上法呢？

递归算法，代码如下

#include <iostream>
using namespace std;
int num=0;
void f(int ,int);

int main()
{
	f(39,0);
	cout<<num;
	return 0;
}

void f(int step,int foot)
{
	if(step==0&&foot%2==0)
	{
		num++;
	}
	if(step<0)
	{
		return;
	}
	f(step-1,foot+1);
	f(step-2,foot+1);
}

 答案为51167078

 问题4 穿越雷区

题目描述

已知的地图是一个方阵，上面用字母标出了A，B区，其它区都标了正号或负号分别表示正负能量辐射区。

例如：

A + - + -

- + - - +

- + + + -

+ - + - +

B + - + -

坦克车只能水平或垂直方向上移动到相邻的区。

数据格式要求：

输入第一行是一个整数n，表示方阵的大小， 4<=n<100

接下来是n行，每行有n个数据，可能是A，B，+，-中的某一个，中间用空格分开。

A，B都只出现一次。

要求输出一个整数，表示坦克从A区到B区的最少移动步数。

如果没有方案，则输出-1

例如：

用户输入：

5

A + - + -

- + - - +

- + + + -

+ - + - +

B + - + -

则程序应该输出：

10

广度搜索（BFS）

#include <bits/stdc++.h>
using namespace std;
 
char Map[101][101]; //地图数组
bool Vis[101][101]; //标记数组 标记是否走过
int Next[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; //方向数组 遍历方向
 
typedef struct node { //定义结构体数组，便于操作调用 包含坐标，步数，符号
	int x, y, step;
	char flag;
} node;
node n[10001]; //BFS数组一般是m*m,再开大一点
 
int main() {
	int m;
	cin >> m;
	getchar(); //吃掉回车
	int head, tail, x, y, tx, ty;
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= m; j++) {
			scanf("%c", &Map[i][j]);
			if (Map[i][j] == 'A') { //记下起点位置的坐标
				x = i, y = j;
			}
			getchar(); //吃掉空格和回车
		}
	}
	head = tail = 1; //初始化 BFS可以理解为一个队列，头和尾
	n[head].x = x;
	n[head].y = y;
	n[head].step = 0;
	n[head].flag = ' ';
	Vis[x][y] = 1; //标记起点位置为走过了
	tail++;
	while (head < tail) { //BFS核心
		for (int i = 0; i < 4; i++) { //遍历4个方向
			tx = n[head].x + Next[i][0];
			ty = n[head].y + Next[i][1];
			if (tx > m || ty > m || tx < 1 || ty < 1) //出边界
				continue;
			if (Vis[tx][ty] == 0 && n[head].flag != Map[tx][ty]) { //没走过且符合+-
				Vis[tx][ty] = 1;
				n[tail].flag = Map[tx][ty];
				n[tail].x = tx;
				n[tail].y = ty;
				n[tail].step = n[head].step + 1;
				tail++;
			}
		}
		if (n[head].flag == 'B') { //走到终点
			cout << n[head].step << endl;
			return 0;
		}
		head++;
	}
	cout << "-1"; //走不到终点
	return 0;
}

测试结果

 

 问题5 迷宫

题目描述

下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。

010000

000100

001001

110000

迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。 请注意在字典序中D<L<R<U。（如果你把以下文字复制到文本文件中，请务 必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt， 内容与下面的文本相同）

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个字符串，包含四种字母 D、U、L、R，在提交答案时只填写这个字符串，填 写多余的内容将无法得分

 

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<set>
using namespace std;
 
#define N 30
#define M 50
 
char map[N][M];
int dir[4][2]={{1,0},{0,-1},{0,1},{-1,0}};//D<L<R<U
char ch[4]={'D','L','R','U'};
int vis[N][M]={0};
 
struct point
{
	int x,y;
	string road;
	point(int a,int b)
	{
		x=a;
		y=b;
	}
};
 
void bfs()
{
	queue<point> q;
	point p(0,0);
	p.road="";
	q.push(p);
	vis[0][0]=1;
	while(!q.empty())
	{
		point t=q.front();
		q.pop();
		if(t.x==N-1&&t.y==M-1)
		{
			cout<<t.road<<endl;
			break;
		}
		for(int i=0;i<4;i++)
		{
			int dx=t.x+dir[i][0];
			int dy=t.y+dir[i][1];
			if(dx>=0&&dx<N&&dy>=0&&dy<M)
			{
				if(map[dx][dy]=='0'&&!vis[dx][dy])
				{
					point tt(dx,dy);
					tt.road=t.road+ch[i];//记录路径
					q.push(tt);
					vis[dx][dy]=1;
				}
			}
		}
	}
}
 
int main()
{
	for(int i=0;i<N;i++)
	{
		for(int j=0;j<M;j++)
			scanf("%c",&map[i][j]);
		getchar();//读掉回车 
	}
	bfs();
	return 0;
}

答案为DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR

问题6 跳马

问题描述：

中国象棋半张棋盘如图1所示。马自左下角(0,0)向右上角（m，n）跳。规定只能往右跳，不准往左跳。比如图1中所示为一种跳行路线，并将路径总数打印出来。

输入格式：

只有一行：两个数n，m

输出格式：

只有一个数：总方案数total。

深搜

#include <iostream>
#include <vector>
using namespace std;
struct point
{
    int i;
    int j;
};
int io[]={2,1,-1,-2};
int jo[]={1,2,2,1};
point goal;
int sum=0;
 
int main(){
    void back(point now,point pre);
    int n,m;
    cin >> n >> m;
    int total;
    goal.i=n;
    goal.j=m;
    point now={0};
 
    back(now,now);
 
    cout << sum << endl;
    return 0;
}
void back(point now,point pre){
    if(now.i<0 || now.i>4 || now.j > 8)
        return;
    if(now.i==goal.i && now.j==goal.j){
        sum++;
        return ;
    }
    for(int i=0;i<4;i++){
        point next={now.i+io[i],now.j+jo[i]};
 
        back(next,now);
    }
}
 

 

问题7 路径之谜

小明冒充X星球的骑士，进入了一个奇怪的城堡。

城堡里边什么都没有，只有方形石头铺成的地面。

假设城堡地面是 n x n 个方格。【如图1.png】所示。

按习俗，骑士要从西北角走到东南角。

可以横向或纵向移动，但不能斜着走，也不能跳跃。

每走到一个新方格，就要向正北方和正西方各射一箭。

（城堡的西墙和北墙内各有 n 个靶子）

同一个方格只允许经过一次。但不必做完所有的方格。

如果只给出靶子上箭的数目，你能推断出骑士的行走路线吗？

有时是可以的，比如图1.png中的例子。

本题的要求就是已知箭靶数字，求骑士的行走路径（测试数据保证路径唯一）

输入：

第一行一个整数N(0<N<20)，表示地面有 N x N 个方格

第二行N个整数，空格分开，表示北边的箭靶上的数字（自西向东）

第三行N个整数，空格分开，表示西边的箭靶上的数字（自北向南）

输出：

一行若干个整数，表示骑士路径。

为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3....

比如，图1.png中的方块编号为：

0  1  2  3

4  5  6  7

8  9  10 11

12 13 14 15

示例：

用户输入：

4

2 4 3 4

4 3 3 3

程序应该输出：

0 4 5 1 2 3 7 11 10 9 13 14 15

代码如下 

#include<iostream>
#include <vector>
using namespace std;
int dir[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
int a[25]={0},b[25]={0};
int visit[400]={0};
int x,y;
vector<int> s;
bool dfs(int x,int y,int n,vector<int>& s)
{
	if(x==n-1&&y==n-1)
	{
		for(int i=0;i<n-1;i++)
		if(a[i]!=0||b[i]!=0)
			return false;
			return true;				
	}
	int g,h;
	for(int i=0;i<4;i++)
	{
		g=x+dir[i][0];
		h=y+dir[i][1];
		if(g>=0&&g<n&&h>=0&&h<n)
		{
			if(!visit[g*n+h]&&a[h]&&b[g])
			{
				visit[g*n+h]=1;
				a[h]--;
				b[g]--;
				s.push_back(g*n+h);
				if(dfs(g,h,n,s))
				{
					return true;
				}
				visit[g*n+h]=0;
				s.erase(s.end()-1);
				a[h]++;
				b[g]++;
			}
		}
	}
return false;
}
int main()
{
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
	cin>>a[i];
	for(int i=0;i<n;i++)
	cin>>b[i];
	s.push_back(0);
	a[0]--;
	b[0]--;
	dfs(0,0,n,s);
	for(int i=0;i<s.size();i++)
	cout<<s[i]<<' ';
	return 0;
}

 问题8 未名湖边的烦恼

问题描述

　　每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多了，每天下午收工后，常常一双冰鞋都不剩。

　　每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法）

输入格式

　　两个整数，表示m和n

输出格式

　　一个整数，表示队伍的排法的方案数。

样例输入

3 2

样例输出

5

数据规模和约定

　　m,n∈［0,18］

递归解决

代码如下

 

#include<iostream>
using namespace std;
int fun(int x,int y)
{
	if(x<y) return 0;
	if(0==y) return 1;
    return fun(x-1,y)+fun(x,y-1);
}
int main(){
	int m,n;
	cin>>m>>n;
	int sum=fun(m,n);
	cout<<sum;
}

 问题9 大臣的旅费

问题描述

很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。

为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。

J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋，用于存放往来城市间的路费。

聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。

J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？

输入格式

输入的第一行包含一个整数n，表示包括首都在内的T王国的城市数

城市从1开始依次编号，1号城市为首都。

接下来n-1行，描述T国的高速路（T国的高速路一定是n-1条）

每行三个整数Pi, Qi, Di，表示城市Pi和城市Qi之间有一条高速路，长度为Di千米。

输出格式

输出一个整数，表示大臣J最多花费的路费是多少。

样例输入1

5
1 2 2
1 3 1
2 4 5
2 5 4

样例输出1

135

输出格式

大臣J从城市4到城市5要花费135的路费。

代码如下

#include <stdio.h>

int a[1000][1000];
int flag[1000];
int Max=0;
int sum=0;
void dfs(int s, int n)
{
	int i;
	for(i=1;i<=n;i++)
	{
		if(flag[i]==0&&a[s][i]>0)
		{
			flag[i]=1;
			sum=sum+a[s][i];
			dfs(i,n);
			sum=sum-a[s][i];
			flag[i]=0;
		}
	}
	if(i==n+1)
	{
		if(sum>Max)
			Max=sum;
	}
}

int main()
{	
	int n,b,c,i;
	scanf("%d",&n);
	int money;
	for(i=0;i<n-1;i++)
	{
		scanf("%d%d",&b,&c);
		scanf("%d",&a[b][c]);
		a[c][b]=a[b][c];
	}
	for(i=1;i<=n;i++)
	{
		flag[i]=1;
		dfs(i,n);
		flag[i]=0;
	}
	money=Max*10+(1+Max)*Max/2;
	printf("%d",money);
	return 0;
} 

 问题10 2n皇后问题

Description

给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后

和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两

个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。

Input

输入的第一行为一个整数n，表示棋盘的大小。

接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，

如果一个整数为0，表示对应的位置不可以放皇后。

Output

输出一个整数，表示总共有多少种放法。

Sample Input

No.1

4

1 1 1 1

1 1 1 1

1 1 1 1

1 1 1 1

No.2

4

1 0 1 1

1 1 1 1

1 1 1 1

1 1 1 1

Sample Output

No.1

2

No.2

0

代码如下

#include<bits/stdc++.h> 
#define N 10 
using namespace std; 

  
int n;
  
int map_Q[N][N];
  
int posb[N]={0};  
int posw[N]={0}; 
 
int tot = 0;   
 
bool checkw( int cur) //检查函数
{  
    for( int i = 1; i < cur; i++)  
        if( posw[i] == posw[cur] || abs(i-cur) == abs(posw[i]-posw[cur]))  
            return false;  
    return true;  
}   
 
bool checkb( int cur)  //检查函数
{  
    for( int i = 1; i < cur; i++)  
        if( posb[i] == posb[cur] || abs(i-cur) == abs(posb[i]-posb[cur]))  
            return false;  
    return true;  
}  
 
void dfs_white( int cur)  
{  
    if( cur == n+1)  //白皇后也全部放完，次数+1
    {  
        tot++;  
      }
    for( int i = 1; i <= n; i++)  
    {  
        if( posb[cur] == i) //表示第cur列的第i行位置已经被黑皇后占用，
            continue;        //结束当前循环，i+1
        if( map_Q[cur][i] == 0)  //再判断前提条件是否成立
            continue;  
        posw[cur] = i;    //尝试把第cur列的白皇后放在第i行上
        if( checkw(cur))   //判断能否放置白皇后
            dfs_white(cur+1);  //递归
    }  
}  
  
void dfs_black( int cur)  
{  
    if( cur == n+1)  //当黑皇后处理完时，再处理白皇后
    {  
        dfs_white(1);  
    }  
    for( int i = 1; i <= n; i++)  
    {  
       if( map_Q[cur][i] == 0)  //如果第cur列第i行满足放皇后的前提条件即 mp[cur][i] == 1
            continue;  //如果不满足，则结束当前循环，进行下一次循环即i+1。
         posb[cur] = i;     //就尝试把第cur列的黑皇后放在第i行上
        if( checkb(cur))   //然后判断该尝试是否成立，如成立，则进行递归，如不成立，则尝试把当前列的黑皇后放在下一行(i+1行)上。
            dfs_black(cur+1);  //递归
    }  
}  
  
int main(){     
   cin>>n;
   for( int i = 1; i <= n; i++)   //定义棋盘
       for( int j = 1; j <= n; j++)  
           cin>>map_Q[i][j];    

   dfs_black(1);    //先把黑皇后放在第一列
   cout<<tot<<endl; 
   
   return 0;  
}