题目链接：https://csacademy.com/contest/archive/task/bfs-dfs/
题目大意：给出一个无向图的BFS顺序以及DFS顺序，问原图的邻接表。
解题思路：如果bfs第二个和dfs第二个点不一样则输出-1，否则按照dfs顺序连边，按照bfs给每个点从1连一条边，然后输出即可
根本不用想什么谁是谁的孩子什么的。。
代码：
1 const int maxn = 5000;
2 int n;
3 int bs[maxn], ds[maxn];
4 vector<int> g[maxn];
5
6 int main(){
7 scanf("%d", &n);
8 for(int i = 0; i < n; i++) scanf("%d", &bs[i]);
9 for(int i = 0; i < n; i++) scanf("%d", &ds[i]);
10 if(n == 1){
11 puts("0");
12 return 0;
13 }
14 if(bs[1] != ds[1]) {
15 puts("-1");
16 return 0;
17 }
18 printf("%d
", 2 * n - 3);
19 for(int i = 0; i < n - 1; i++) g[ds[i]].push_back(ds[i + 1]);
20 for(int i = 2; i < n; i++) g[1].push_back(bs[i]);
21 for(int i = 1; i <= n; i++){
22 for(int j = 0; j < g[i].size(); j++){
23 printf("%d %d
", i, g[i][j]);
24 }
25 }
26 }
题目：
BFS-DFS
Memory limit: 128 MB
In this problem you are given the two orders of visiting the nodes in a BFS and a DFS, starting in node 11. Generate the edge list of a simple, undirected, connected graph corresponding to these orders.
Statement clarification
One of the standard ways of storing a graph is using adjacency lists. Usually, the input is given as a list of edges. The program reads the numbers of nodes and edges, creates an empty list for each node, and then proceeds to read the edges. When an edge (a, b)(a,b) is read, aa is appended to the list of bb and bb is appended to the list of aa. Consider the following input:
We have a graph with 66 nodes and 88 edges:
123456
And we create the following lists:
- Node 11: [3, 5, 6][3,5,6]
- Node 22: [5, 6][5,6]
- Node 33: [1, 4, 5][1,4,5]
- Node 44: [3][3]
- Node 55: [1, 2, 3, 6][1,2,3,6]
- Node 66: [1, 2, 5][1,2,5]
In this problem we are concerned with the two most popular algorithms for traversing a graph: the Breadth First Search (BFS) and the Depth First Search (DFS).
The BFS pushes the starting node in a queue. While the queue is not empty, we pop the first node from the queue, go through its adjacency list, and enqueue the unvisited neighbours.
The DFS is usually implemented as a recursive function. First we call the function for the starting node. For each call, we go through the adjacency list of the current node, and recursively call the function for the unvisited neighbours.
Notice that the order of visiting the nodes is uniquely determined for both algorithms.
Standard input
The first line contains a single integer NN, representing the number of nodes.
The second line contains a permutation of size NN, representing the order of visiting the nodes for the BFS.
The third line contains a permutation of size NN, representing the order of visiting the nodes for the DFS.
Standard output
If there is no solution, output -1−1.
Otherwise, print a single integer MM, representing the number of edges, on the first line.
Each of the next MM lines should contain two integers aa and bb representing two nodes that share an edge.
Constraints and notes
- 1 leq N leq 40961≤N≤4096
- The number of edges MM should be at most 10^5105
- The two permutations will always start with 11
- The graph is considered to be undirected. Multiple edges and self loops are not allowed, and the graph should be connected.
| Input | Output | Explanation |
|---|---|---|
6
1 3 5 6 4 2
1 3 4 5 2 6
|
8
1 3
1 5
1 6
2 5
2 6
3 4
3 5
5 6
|
The labels on the edges represent the indices in the output edges. 12345678123456 |
4
1 2 4 3
1 2 3 4
|
4
1 2
1 4
3 4
2 3
|
12341234 |
6
1 2 6 3 4 5
1 2 6 3 4 5
|
7
1 2
2 6
2 3
2 4
4 5
1 6
3 4
|
1234567123456 |
8
1 3 5 4 7 8 2 6
1 3 7 2 8 6 5 4
|
10
2 8
1 3
1 5
3 7
2 7
1 4
4 2
2 6
8 6
5 8
|
1234567891012345678 |