洛谷题单 算法1-7 搜索

八皇后

题目链接
思路分析：这是一道需要使用dfs的题，本来考虑用二维数组来记录放皇后的位置，但是题目中的左对角线和右对角线的标记和清除就比较麻烦，看了一下题解，觉得设置4个数组分别表示行，列，左对角线和右对角线。
代码：

#include<stdio.h>
int n;
int a[100],b[100],c[100],d[100];//用来标记行，列，左对角线，右对角线 
int all;//记录解的个数 
void dfs(int i)//传入当前行数 
{
	if(i>n)
	{
		if(all<3)
		{
			int k;
			for(k=1;k<=n;k++)
				printf("%d ",a[k]);
				printf("\n");
				
		}
		all++;
		return ;
		
	}
	else//尝试每一个可能的列数
	{
		int j;
		for(j=1;j<=n;j++)
		{
			if(b[j]==0&&c[j-i+n]==0&&d[i+j]==0)//如果该位置合适 
		    {
		    	a[i]=j;
		    	b[j]=1;
		    	c[j-i+n]=1;
		    	d[i+j]=1;
		    	
		    	dfs(i+1);
		    	
		    	b[j]=0;
		    	c[j-i+n]=0;
		    	d[i+j]=0;
			}
		}
		
	} 
	
}
int main()
{
	scanf("%d",&n);
	dfs(1);
	
	printf("%d\n",all);
	return 0;
	
}

奇怪的电梯

题目链接
注意：记得判断如果当前的步数已经＞记录的最小步数，就可以回溯，否则有的测试点就会超时。有一个测试的WA了，不鸡丢咋回事呀，望大神指点…

#include<stdio.h>
int N,A,B;
int K[205];
int min=oxffffffff;//记录最小的按键次数 
int book[205];
void dfs(int a,int step)//传入当前的层数 ,和按键次数 
{
	if(a==B)//到达B时 
	{
		if(step<min)
		    min=step;
		step=0;
		
		return; 
	}
	else if(a<B)//未到达时
	{
		if(step>min) return;
		
		book[a]=1;
		if(a-K[a]>=1&&a-K[a]<=N&&book[a-K[a]]==0)
		{
			book[a-K[a]]=1;
			dfs(a-K[a],step+1);
			book[a-K[a]]=0;
			
		}
		if(a+K[a]>=1&&a+K[a]<=N&&book[a+K[a]]==0)
		{
			book[a+K[a]]=1;
			dfs(a+K[a],step+1);
		    book[a+K[a]]=0;
		}
		
	} 
	
}
int main()
{
	scanf("%d %d %d",&N,&A,&B);
	int i;
	for(i=1;i<=N;i++)
	    scanf("%d",&K[i]);
	    
	    dfs(A,0);
	    if(min!=oxffffffff)
	    printf("%d",min);
	    else printf("-1");
	    return 0;
	    
} 

考前临时抱佛脚

题目链接
分析：这道题中说左右脑可以同时写题，太强了吧，但是有限制，左右脑想的题目必须是同一科，这也就暗示我们用贪心，求出每门科所用最短时间相加即可，每门科的最短时间我们可以用dfs，找出所用方案，最终的最短时间也就是左右脑中较长时间中的最短时间。
代码：

#include<stdio.h>
int s[5];
int a[5][21];
int all;
int right,left;//左右脑 
int min=9999999;
void dfs(int x,int y)//x表示习题，y表示科目 
{
	if(x>s[y])//当习题全部写完
	{
		int t;
		if(right>left) t=right;
		else t=left;
		
		if(t<min)
		min=t;
		
		return ;
		
	}
	else//将当前的习题加到左脑或者有脑，较小的那个 
	{
			right+=a[y][x];
			dfs(x+1,y);
			right-=a[y][x]; 
		
			left+=a[y][x];
			dfs(x+1,y);
			left-=a[y][x];
	
	} 
	
}
int main()
{
	scanf("%d %d %d %d",&s[1],&s[2],&s[3],&s[4]);
	int i,j;
	for(i=1;i<=4;i++)
	{
		for(j=1;j<=s[i];j++)
		{
			scanf("%d",&a[i][j]);
		}
		dfs(1,i);
		all+=min;
		right=left=0;
		min=9999999;
	}
	printf("%d",all);
	return 0;
}

马的遍历

题目链接
分析：我看题目算法标签就是bfs，然后我就用bfs加队列写的。刚开始傻呼呼的我把队列开成1601也是没谁了，其实应该是160000+才对，哈哈哈哈。
代码：

#include<stdio.h>
#include<math.h>
//队列的节点结构 
struct node 
{
	int x;
	int y;
	
	
}queue[160010];	//行列小于等于400，队列扩展不会超过160000个 
int book[401][401];//标记哪些点已经到达
int ans[401][401];//记录每个点所能到达的最短步数
int i,j,m,n,tx,ty,sx,sy;//sx,sy开始的横纵坐标，tx，ty下一步横纵坐标
void bfs(int sx,int sy,int sstep)
{
	int head,tail;//队列头，尾 
	//一共八个方向，即去掉x，y绝对值相等的坐标，根据画图可得 
	int next_x[4]={1,-1,2,-2};
	int next_y[4]={1,-1,2,-2};
    ans[sx][sy]=sstep;
    book[sx][sy]=1;
    head=1;
    tail=1;
    queue[1].x=sx;
    queue[1].y=sy;
    
    tail++;
    int flag;//判断当前点能否继续扩展 
    while(tail>head)//当队列不为空，也就是当最后队列无法继续扩展时结束循环
	{
		
		//枚举8个方向
		for(i=0;i<4;i++)
		{
			for(j=0;j<4;j++)
			{
				if(abs(next_x[i])!=abs(next_y[j]))//横纵坐标绝对值不相等时
				{
					tx=queue[head].x+next_x[i];
					ty=queue[head].y+next_y[j];
					//判断是否出界以及是否走过 
					if(tx<1||tx>m||ty<1||ty>n)
					continue;
					if(book[tx][ty]==0)
		   			    {
		   			    	book[tx][ty]=1;//标记走过
		   			    	
							queue[tail].x=tx;
							queue[tail].y=ty;
							tail++;
							
							ans[tx][ty]=ans[queue[head].x][queue[head].y]+1;//步数加一 
		   			    	
						} 
					
				} 
			}
		 } 
		head++;
		
	}
}
int main()
{

	scanf("%d %d %d %d",&m,&n,&sx,&sy);//m行，n列
	bfs(sx,sy,0);
	
	for(i=1;i<=m;i++)
	{
		for(j=1;j<=n;j++)
		{
			if(i==sx&&j==sy)
			{
				printf("%-5d",0);
			}
			else if(ans[i][j]==0)
			    printf("%-5d",-1);
			    else printf("%-5d",ans[i][j]);
		}
		printf("\n");
	 } 
	 
	 return 0;
}