学习之旅week10

二分

 while(minn<=maxx){ //二分的套路
            int mid=(maxx+minn)/2;
            if(check(mid)){
                minn=mid+1;
                ans=mid;
            }else{
                maxx=mid-1;
            }

DFS

不撞南墙不回头
试错+反悔的过程
全排列：

#include<bits/stdc++.h>
using namespace std;
int a[20],b[20]={0};
int n;

void dfs(int step){
	if(step>n){
		for(int i=1;i<=n;i++){
			cout<<a[i];
		}
		cout<<endl;
		return ;
	}
	for(int i=1;i<=n;i++){
		if(b[i]==1){
			continue;
		}
		a[step]=i;
		b[i]=1;
		dfs(step+1);
		b[i]=0;
	}
}
int main(){
	cin>>n;
	dfs(1);
	return 0;
}

BFS

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

struct node{
	int x;
	int y;
	int f;//父亲在队列中的编号 
	int s;//步数 
};

int main(){
	struct node que[2501];//地图大小
	
	int a[51][51]={0},book[51][51]={0};
	int next[4][2]={{0,1},{0,-1},{1,0},{-1,0}};//方向
	
	int head,tail;
	int n,m;
	int sx,sy,p,q;
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			scanf("%d",&a[i][j]);
		
		}
	}
	scanf("%d %d %d %d",&sx,&sy,&p,&q);
	//队列初始化
	head=1;
	tail=1;
	//插入迷宫入口坐标
	que[tail].x=sx;
	que[tail].y=sy;
	que[tail].f=0;
	que[tail].s=0;
	tail++;
	book[sx][sy]=1;
	int flag=0;//用来标记是否到达目的地
	while(head<tail){//当队列为空时循环
		for(int k=0;k<4;k++){//枚举4个方向
			//计算下一个点的坐标
			int tx=que[head].x+next[k][0];
			int ty=que[head].y+next[k][1];
			//判断是否越界
			if(tx>n||ty>m||tx<1||ty<1){
				continue;
			}
			//判断是否为障碍物或者已经在路径中
			if(a[tx][ty]==0&&book[tx][ty]==0){
				book[tx][ty]=1;
				que[tail].x=tx;
				que[tail].y=ty;
				que[tail].f=head;//路径
				que[tail].s=que[head].s+1;
				tail++;
				//每个点只入队一次，故不需要将book数组还原
			}
			if(tx==p&&ty==q){
				//不可以写反
				flag=1;
				break;
			}
		}
		if(flag==1){
			break;
		}
		head++;
		//当一个点扩展后，一定要head++才能对后面的点再进行扩展
	}
	printf("%d",que[tail-1].s);
	return 0;
} 

输入 ：
5 4
0 0 1 0
0 0 0 0
0 0 1 0
0 1 0 0
0 0 0 1
1 1 4 3

图的广度优先遍历

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

struct node{
	int x;//城市编号
	int s;//转机次数
};

int main(){
	struct node que[2501];
	
	int e[51][51]={0},book[51]={0};
	
	int head,tail;
	int n,m;
	int sx,ex;
	scanf("%d %d %d %d",&n,&m,&sx,&ex);
	//初始化二维数组
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(i==j){
				e[i][j]=0;
			}else{
				e[i][j]=9999999;
			}
		}
	}
	int a,b;
	//读入城市间的航班
	for(int i=1;i<=m;i++){
		scanf("%d %d",&a,&b);	
		e[a][b]=1;
		e[b][a]=1;
	}
	//队列初始化
	head=1;
	tail=1;
	//从sx号城市出发，将sx号城市加入队列
	que[tail].x=sx;
	que[tail].s=0;
	tail++;
	book[sx]=1;//标记
	
	int flag=0;
	//当队列不为空的时候循环
	while(head<tail){
		for(int j=1;j<=n;j++){
			if(e[que[head].x][j]!=9999999&&book[j]==0){
				//如果从城市que[head].x到城市j有航班并且城市j不在队列中，则将j号城市入队
				que[tail].x=j;
				que[tail].s=que[head].s+1;//转机次数+1
				tail++;
				book[j]=1;//标记
			}
			//如果到达目的地，停止扩展，任务结束，退出循环
			if(que[tail-1].x==ex){
				flag=1;
				break;
			}
		}
		if(flag==1){
			break;
		}
		head++;
	}
	printf("%d",que[tail-1].s);//因为tail是指向队尾的下一个位置，所以这里要减一
	return 0;
}

输入：
5 7 1 5
1 2
1 3
2 3
2 4
3 4
3 5
4 5

Floyd-Warshaii算法

概括：从i号顶点到j号顶点只经过前k号点的最短路径

for(int k=1;k<=n;k++){
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(e[i][j]>e[i][k]+e[k][j]){
				e[i][j]=e[i][k]+e[k][j];
			}
		}
	}
}

Bellman-Ford算法

#include<stdio.h>
int main(){
	int dis[10];
	int n,m,u[10],v[10],w[10];
	scanf("%d %d",&n,&m);//n表示顶点个数，m表示边的条数
	//读入边
	for(int i=1;i<=m;i++){
		scanf("%d %d %d",&u[i],&v[i],&w[i]);
	}
	//初始化数组，这里是1号顶点到其余各个顶点的初始路程
	for(int i=1;i<=n;i++){
		dis[i]=9999999;
	}
	dis[1]=0;
	//核心算法
	for(int k=1;k<=n-1;k++){
		for(int i=1;i<=m;i++){
			if(dis[v[i]]>dis[u[i]]+w[i]){
				dis[v[i]]=dis[u[i]]+w[i];
			}
		}
	}
	//输出结果
	for(int i=1;i<=n;i++){
		printf("%d ",dis[i]);
	}
	return 0;
}

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

习题

B:

#include <cstdio>
#include <string.h>

int chess[11][11],T,n,m,x0,y0,ans,nm;
int next[8][2]={{1,2},{-1,2},{1,-2},{-1,-2},{2,1},{-2,1},{2,-1},{-2,-1}};//八个方向

void dfs(int x,int y,int step){
	if(step==nm){//深搜
		ans++;
	}else{
		for(int i=0;i<8;i++){
			int tx=x+next[i][0];
			int ty=y+next[i][1];
			if(tx>=0&&ty>=0&&tx<n&&ty<m&&chess[tx][ty]==0){
				chess[tx][ty]=1;
				dfs(tx,ty,step+1);
				chess[tx][ty]=0;//回溯
			}
		}
	}
}

int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		memset(chess,0,sizeof(chess));//棋盘全部置0
		scanf("%d%d%d%d",&n,&m,&x0,&y0);
		nm=n*m;
		ans=0;
		chess[x0][y0]=1;
		dfs(x0,y0,1);
		printf("%d\n",ans);
	}
	return 0;
}

A：

#include<bits/stdc++.h>
using namespace std;
int n,flag;
void dfs(long long sum,int num){
	if(flag||num==19){
		return ;
	}
	if(sum%n==0){
		cout<<sum<<endl;
		flag=1;//如果是N的倍数，就输出 并且标记为1，退出搜索
	}else{
		dfs(sum*10,num+1);//不是10就是11
		dfs(sum*10+1,num+1);
	}
}
int main(){
	while(~scanf("%d",&n)&&n){
		flag=0;
		dfs(1,0);//第一个数是1，刚开始为0位
	}
	return 0;
}

C：

#include<stdio.h>
#include<string.h>

int n,k,flag,ans;
char chess[10][10];
int t[10];

void dfs(int a,int b){//A为行数，B为已经放的棋子数
	if(b==k){//如果棋子数放满，方法增加
		ans++;
		return ;
	}
	if(a>=n){//如果行数大于等于输入的行数
		return ;
	}
    for(int i = 0; i<n; i++){
        if(!t[i]&&chess[a][i]=='#'){
            t[i] = 1;
            dfs(a+1,b+1);
            t[i] = 0;//回溯
        }
    }
    dfs(a+1,b);//当前行搜完后搜索下一行
}
int main(){
	while(~scanf("%d%d",&n,&k)){
		if(n==-1&&k==-1){
			return 0;
		}
		ans=0;
		for(int i=0;i<n;i++){
			scanf("%s",chess[i]);
		}
		memset(t,0,sizeof(t));
		dfs(0,0);
		printf("%d\n",ans);
	}
	return 0;
}

F:二分法

#include<bits/stdc++.h>
using namespace std;
int N,C;//N个房间，C只鹅
int a[100005];

bool check(int x){//检查按照X个间隔可不可以把所有鹅都放进去
	int count=1,pos=1;
	for(int i=2;i<=N;i++){//走完所有房间，判断距离
		if(a[i]-a[pos]>=x){
			count++;//鹅的数量++
			pos=i;//位置增加
		}
		if(count>=C){
			return true;
		}
	}
	return false;
}

int main(){
	while(~scanf("%d%d",&N,&C)){
        int ans=0;
        for(int i=1;i<=N;i++){
            cin>>a[i];
        }
        sort(a+1,a+1+N);
        int maxx=a[N],minn=0;
       // 1 2 4 8 9
        while(minn<=maxx){ //二分的套路
            int mid=(maxx+minn)/2;
            if(check(mid)){
                minn=mid+1;
                ans=mid;
            }else{
                maxx=mid-1;
            }
            //cout<<ans<<" "<<minn<<" "<<maxx<<" "<<mid<<endl;
            /*
            0 0 3 4
            1 2 3 1
            2 3 3 2
            3 4 3 3
            */
        }
        cout<<ans<<endl;
	}
	return 0;
}

M:

#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
int t;
double y;

double jisuan(double x){//计算函数值
    return 6*pow(x,7)+8*pow(x,6)+7*pow(x,3)+5*pow(x,2)-y*x;
}

double daoshu(double x){//求导
    return 42*pow(x,6)+48*pow(x,5)+21*pow(x,2)+10*x-y;
}
int main(){
    cin>>t;
    while(t--){
        cin>>y;
        double l=0,r=100,mid;//二分法
        while(l+0.00001<=r){
            mid=(l+r)/2;
            if(daoshu(mid)>0){//如果导数大于0，导数的零点一定在该点左边，故右边界取中点
                r=mid;

            }else{
                l=mid;
            }
        }
        printf("%.4lf\n",jisuan(mid));
    }
    return 0;
}

Q:

#include<iostream>
using namespace std;
 
int a[5][5];
int next[4][2]={{-1,0},{1,0},{0,-1},{0,1}};//方向

struct Node{
	int x;
	int y;
	int pre;//父亲
}que[50];

int head=0;
int tail=0;
int book[5][5];

void bfs(int beginX,int beginY,int endX,int endY){
	int next[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
	que[0].x=beginX,que[0].y=beginY,que[0].pre=-1;//将初始位置压入队列
	tail++;
	book[beginX][beginY]=1;
	while(head<tail){
		for(int k=0;k<4;k++){
			int tx=que[head].x+next[k][0];
			int ty=que[head].y+next[k][1];
			if(tx<0||tx>5||ty<0||ty>5||a[tx][ty]==1||book[tx][ty]==1){
				continue;
			}
			que[tail].x=tx;
			que[tail].y=ty;
			que[tail].pre=head;
			tail++;
			book[tx][ty]=1;
			if(tx==endX&&ty==endY){
				return;
			}
		}
		head++;
	}
}
 
void print(Node now){//倒叙
	if(now.pre==-1){
		cout<<"("<<now.x<<", "<<now.y<<")"<<endl;
	}else{
		print(que[now.pre]);
		cout<<"("<<now.x<<", "<<now.y<<")"<<endl;
	}
}
 
int main(){  
   for(int i=0;i<5;i++){
	   for(int j=0;j<5;j++){
		    cin>>a[i][j];
	   }	  
   }
   bfs(0,0,4,4);
   print(que[tail-1]);//tail指向队列末尾元素的下一个位置，故这里要-1
   return 0;
}

pre成员：
用来表示从左上角到右下角的最短路径中每个元素的前一个元素的下标，即保存路径，方便后面的输出。