洛谷【数据结构1-2/4】二叉树/图

二叉树

P4913 【深基16.例3】二叉树深度

#include
using namespace std;
const int maxn = 100010;

struct node{
	int left,right;
}tree[maxn]; 
int n,ans;
void dfs(int id,int deep){
	if(id == 0) return;//到达叶子结点返回 
	ans = max(ans,deep);
	dfs(tree[id].left,deep+1);
	dfs(tree[id].right,deep+1);
}
int main(){

	scanf("%d",&n);//节点数
	for(int i=1;i<=n;i++){
		scanf("%d %d",&tree[i].left,&tree[i].right);
	}
	dfs(1,1);
	printf("%d\n",ans);
	return 0;
}

P1229 遍历问题

已知前序和后序遍历序列，求中序遍历序列的个数。

只知道前序和后序序列，中序序列的不确定性在于不知道子节点是左子树还是右子树。

a b c
c b a

根节点为a，根节点的左子树一定是以b为根节点，此时若b恰好为后序序列的a之前一位，那么说明根节点a没有第二棵子树，此时子树bc可以为左子树也可以为右子树，因此有两种情况。

a b c
b c a

此时，则bc分别为a的左右子树，中序序列固定，只有一种情况。

因此使用DFS对一棵树进行深搜，左子树的情况*右子树的情况 * 总根节点a的情况即为总的中序序列个数。

递归边界为：此时树只有一个结点或无节点，则只有一种情况。

int ltree = index[s1[st1+1]]-st2+1;

计算左子树的长度，需要一个index数组记录下来后序序列中每个字符的位置。

for(int i =0;i<len;i++){
		index[s2[i]] = i;//记录s2中每个字符的位置 
	}

此时左子树的根节点在后序序列中的位置-后序序列开头index+1，即为左子树的结点个数。

if(st1+ltree == en1) k=2;

如果先序序列根节点index+左子树结点个数== 先序序列的最后一个节点index，则根节点只有一个子树，此时子树情况有两种，可以为左或右。

之后再对先序序列根节点的左子树和右子树分别进行dfs，得到每一层的情况数，再相乘即为最后的结果。

#include
using namespace std;
const int maxn = 1010;

string s1,s2;
int index[maxn];
int dfs(int st1,int en1,int st2,int en2){
	if(st1>=en1) return 1;//只有一个结点或者无节点，是一种情况
	int ltree = index[s1[st1+1]]-st2+1;//得到st1根节点左子树的长度
	int k =1;//假设子节点只有一种情况 
	if(st1+ltree == en1) k=2;//如果st1只有一个子节点，则可以为左节点也可以为右节点，k=2种情况 
	return (dfs(st1+1,st1+ltree,st2,st2+ltree-1) * dfs(st1+ltree+1,en1,st2+ltree,en2) ) * k;
}
int main(){
	cin>>s1;//前序序列 
	cin>>s2;//后序序列 
	int len = s2.length();
	for(int i =0;i<len;i++){
		index[s2[i]] = i;//记录s2中每个字符的位置 
	}
	int cnt =dfs(0,s1.length()-1,0,len-1);
	printf("%d\n",cnt);
	return 0;
}

图

P5318 查找文献

int n,m;//n篇文章,m个引用关系 
vector<int> adj[maxn]; //使用邻接表存图 
bool vis[maxn];
bool inq[maxn];

void dfs(int u){
	vis[u] = true;
	printf("%d ",u);//打印dfs遍历序列 
	for(int i=0;i<adj[u].size();i++){
		int v = adj[u][i];
		if(vis[v]==false){
			dfs(v);
		}
	}
}
void dfsG(){
	for(int u =1;u<=n;u++){
		if(vis[u]==false){
			dfs(u);
		}
	}
}
void bfs(int u){
	queue<int> q;
	q.push(u);
	inq[u] = true;
	while(!q.empty()){
		int temp = q.front();
		printf("%d ",temp);
		q.pop();
		for(int i=0;i<adj[temp].size();i++){
			int v = adj[temp][i];
			if(inq[v]==false){
				q.push(v);
				inq[v] = true;
			}
		}
	}
}
int main(){
	scanf("%d %d",&n,&m);
	for(int i=0;i<m;i++){
		int a,b;
		scanf("%d %d",&a,&b);
		adj[a].push_back(b);
	}
	for(int i=1;i<=n;i++){
		sort(adj[i].begin(),adj[i].end());
	}
	dfsG();
	printf("\n");
	bfs(1);
	return 0;
} 

P3916 图的遍历

#include
using namespace std;
const int maxn =500100;

int n,m;
vector<int> adj[maxn];
int a[maxn];

void dfs(int s,int k){
	if(a[s]) return;
	a[s] =k;
	for(int i=0;i<adj[s].size();i++){
		dfs(adj[s][i],k);
	}
}
int main(){
	scanf("%d %d",&n,&m);
	for(int i =1;i<=m;i++){
		int a,b;
		scanf("%d %d",&a,&b);
		adj[b].push_back(a);//反向建图 
	}
	
	for(int i=n;i>=1;i--){
		dfs(i,i);
	}
	for(int i =1;i<=n;i++){
		printf("%d ",a[i]);
	}
	return 0;
}

P1807 最长路

#include
using namespace std;
const int maxn =1510;
const int INF = 0x3fffff;

int n,m;
int G[maxn][maxn];
int dp[maxn];//从i到n的最长距离 
bool vis[maxn];

int Qdp(int x){
	if(vis[x]==true) return dp[x];//x已经计算过 
	vis[x] = true;
	for(int i=1;i<=n;i++){//遍历所有x出边 
		if(G[x][i]!=0){
			dp[x] = max(dp[x],Qdp(i)+G[x][i]);  
		}
	}
	return dp[x];
}

int main(){
	memset(vis,0,sizeof(vis));
	scanf("%d %d",&n,&m);
	for(int i =0;i<m;i++){
		int u,v,w;
		scanf("%d %d %d",&u,&v,&w);
		if(G[u][v]!=0){
			if(G[u][v]>w){
				continue;
			}
		}else{
			G[u][v] = w;			
		}
	}
	fill(dp,dp+n,-INF);//初始化i和n不可达 
	dp[n] = 0;//边界 
	vis[n] = true;
	Qdp(1);
	if(dp[1] == -INF){
		printf("-1\n");
	}else
		printf("%d\n",dp[1]);
	return 0;
}

P1127 词链

#include
using namespace std;
const int maxn =1010;
//const int INF = 0x3fffff;

int n;
int G[maxn][maxn];//存图 
string s[maxn];
int len[maxn];//记录字符串的长度 
int st[maxn],en[maxn];//统计出现次数(求起始单词) 
bool vis[maxn];
string now[maxn],ans[maxn];//暂存接龙方案,最终答案 
int flag =0,sum=0;//标记是否找到方案 

int findS(){//找起始单词 
	for(int i =1;i<=n;i++){
		if(st[s[i][0]]-en[s[i][0]] == 1)
			return i;
	}
	return 1;//找不到满足规则的，就把第一个当做起始单词 
} 
void dfs(int last,int step){
	if(flag==1) return;//找到了最短方案立即返回 
	if(step == n){
		flag=1;
		for(int i =1;i<=sum;i++){
			ans[i] = now[i];
		}
		return;
	}
	for(int i=1;i<=n;i++){
		if(vis[i]==true) continue;//已访问过 
		if(G[last][i] == 1){//可以匹配上 
			now[++sum] = s[i];
			vis[i]=true;
			dfs(i,step+1);
			vis[i] = false;//回溯 
			sum--;
		}
	}
}
int main(){
	memset(st,0,sizeof(st));
	memset(en,0,sizeof(en));
	memset(G,0,sizeof(G));
	memset(vis,false,sizeof(vis));
	scanf("%d",&n);
	for(int i =1;i<=n;i++){
		cin>>s[i];
	}
	sort(s+1,s+1+n);
	for(int i =1;i<=n;i++){
		len[i] = s[i].length();
	}
	for(int i=1;i<=n;i++){//找边 
		for(int j =1;j<=n;j++){
			if(i==j) continue;//减少次数
			if(s[i][len[i]-1]==s[j][0]) G[i][j]=1;
		}
	}
	for(int i =1;i<=n;i++){//统计出现次数 
		st[s[i][0]]++;
		en[s[i][len[i]-1]]++;
	}
	int start = findS();
	vis[start] = true;
	now[++sum] = s[start];//存入方案
	dfs(start,1);
	if(flag ==0){
		printf("***\n");
		return 0;
	} 
	for(int i=1;i<=n;i++){
		if(i!=n) cout<<ans[i]<<".";
		else cout<<ans[i];
	}
	return 0;
}

P1363 幻象迷宫

#include
using namespace std;
const int maxn =1510;
//const int INF = 0x3fffff;
int  n,m;
int G[maxn][maxn];//地图 
int dis[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};
int vis[maxn][maxn][3];//第一维代表访问过,第二维代表x坐标,第三维代表y坐标 
bool flag = false;
int stx,sty;
//如果走到过某个点现在又走到了这个点，那显然是可以走无限远的
void dfs(int x,int y,int lx,int ly){//取模的坐标xy和未取模的lx/ly 
	if(flag == true) return;
	if(vis[x][y][0]&&(vis[x][y][1]!=lx ||vis[x][y][2]!=ly)){
		flag = true;
		return;
	}
	vis[x][y][1] = lx,vis[x][y][2] = ly,vis[x][y][0] = true;
	for(int i=0;i<4;i++){
		int nx = (x+dis[i][0]+n)%n, ny=(y+dis[i][1]+m)%m;//防止负数先+再% 
		int nlx = lx+dis[i][0],nly=ly+dis[i][1];
		if(G[nx][ny]==0){
			if(vis[nx][ny][1]!=nlx||vis[nx][ny][2]!=nly ||vis[nx][ny][0]==0){
				dfs(nx,ny,nlx,nly);
			}
		} 
	}
}
int main(){
	while(scanf("%d %d",&n,&m) != EOF){
		flag = false;
		memset(G,0,sizeof(G));
		memset(vis,0,sizeof(vis));
		char ch;
		for(int i=0;i<n;++i){
			for(int j=0;j<m;++j){
				cin >>ch;
				if(ch=='#') G[i][j] = 1;//墙 
				if(ch=='S'){//找到起点 
					stx = i; sty =j;
				}
			}
		}
		dfs(stx,sty,stx,sty);
		if(flag==true) cout<<"Yes"<<endl;
		else cout<<"No"<<endl;
	}
	return 0;
}