Can't figure out this graph presentation (Algorithm needed!) - algorithm

Question

I've been struggling a lot to make sense out of this graph presentation without any proper solution. Maybe someone could figure something out.
I have a presentation of connected, cycle free graph that forms as follows:
Remove vertices which has a degree of 1 (has only one edge) one by one
If there is more than one option, vertex with the lowest value will be removed
When vertex is removed, the vertex next to it will me marked
This will go on until graph has only one vertex left
Heres an example graph:
2 3
\ /
5 1
\ /
4
And this is how the presentation forms:
2 3 3
\ / /
5 1 => 5 1 => 5 1 => 5 => 5
\ / \ / \ / \
4 4 4 4
1. Remove vertex two and mark one.
2. Remove vertex three and mark one.
3. Remove vertex one and mark four.
4. Remove vertex four and mark five.
So the presentation for this graph would be:
1 1 4 5
The problem is, how can I turn this presentation into adjacency matrix or adjacency list?
F.e. with 1 1 4 5, the adjacency list would look like this:
1: 2 3 4
2: 1
3: 1
4: 1 5
5: 4
Thank you!

Answer 1

Ah! because of the insufficient info in the original question (especially the info: tree will have 1 to n+1 nodes, where n is the length of input array), I tried to solve it in much harder way! Anyway, here is my Prufer-tree generation implementation, maybe it will help :-? :
#include <stdio.h>
#include <vector>
#include <memory.h>
using namespace std;
struct Node {
int N;
vector<int>list;
Node() {
N=-1;
list.clear();
}
};
vector<Node> convertPruferToTree(vector<int>& input) {
int n = input.size()+1;
vector<Node> T;
int *degree = new int[n+1];
for (int i=1; i<=n; i++) {
Node tmp;
tmp.N = i;
T.push_back(tmp);
degree[i]=1;
}
//printf("n: %d\n", n);
for (int i=0; i<input.size()-1; i++) {
degree[input[i]]++;
}
for (int i=0; i<input.size()-1; i++) {
for (int j=1; j<=n; j++) {
if (degree[j]==1) {
T[j-1].list.push_back(input[i]);
T[input[i]-1].list.push_back(j);
degree[input[i]]--;
degree[j]--;
break;
}
}
}
int u=0, v=0;
for (int i=1; i<=n; i++) {
if (degree[i]==1) {
if (u==0) u=i;
else {
v = i;
break;
}
}
}
//printf("u: %d v: %d\n", u, v);
T[u-1].list.push_back(v);
T[v-1].list.push_back(u);
delete []degree;
return T;
}
int main () {
vector <int> input;
int n,v;
scanf("%d", &n);
while(n--) {
scanf("%d", &v);
input.push_back(v);
}
vector<Node> adjList = convertPruferToTree(input);
Node tmp;
for (int i=0; i<adjList.size(); i++) {
tmp = adjList[i];
printf("%2d: ", tmp.N);
for (int j=0; j<tmp.list.size(); j++) {
printf("%2d ", tmp.list[j]);
}
printf("\n");
}
return 0;
}

Answer 2

Here is the naive implementation in python:
from collections import defaultdict
prufer_sequence = [1, 1, 4, 5]
all_vertices = range(1, len(prufer_sequence) + 2)
adjacency = defaultdict(list)
for vertex in prufer_sequence:
searched_vertex = filter(lambda v: v != vertex, all_vertices)[0]
all_vertices.remove(searched_vertex)
adjacency[vertex].append(searched_vertex)
adjacency[searched_vertex].append(vertex)
print adjacency
And output:
defaultdict(<type 'list'>, {1: [2, 3, 4], 2: [1], 3: [1], 4: [1, 5], 5: [4]})

Answer 3

The "presentation" (1 1 4 5 in your example) can be turned back into a graph using the following technique (which, from your comment above, is the bit I think you're struggling with). You can then trivially produce an adjacency matrix/list.
This technique relies on the key assumption that the nodes in the graph were labelled 1 - N (where there are N nodes in the graph). If this is not the case, it is fundamentally impossible to reconstruct the original graph because you can never determine the identity of the first removed node.
Note that there are 4 items in the presentation. Therefore, there are 5 nodes in the graph.
Work backwards from the end of the presentation.
When the last node was removed, the node that was left was 5. Therefore, the graph looks like...
5 - ?
When the previous item was removed, 4 was marked. Therefore, the original question-mark must actually be node 4, and we have a new unknown node.
5 - 4 - ?
When the previous item was removed, 1 was marked. Therefore, the ? must be a 1 and there's a new unknown node.
5 - 4 - 1 - ?A
Finally, when the previous item was removed, 1 was marked. We already have a node 1, so we must attach to that.
5 - 4 - 1 +- ?A
|
+= ?B
We've finished parsing the input. Now we just need to label the outstanding ?s. We know that the values are 2 and 3 because of the assumption stated above that the nodes are labelled 1 - N and we already have 1, 2 & 5. Because lowest value nodes are removed first (when turning the graph into the presentation), they are added last when converting a presentation to a graph. So ?A = 3 and ?B = 2. (In this case it doesn't matter, but in the general case it does.) That leaves that final graph as follows.
5 - 4 - 1 +- 3
|
+= 2
...which is good because that's the same as where we started.
From this you can iterate over the nodes and produce your adjacency matrix. Alternatively, so can produce an adjacency list/matrix as you go along (which is likely to be more efficient, but slightly confuses the implementation).
And as David pointed out above, this is very similar (but not quite identical) to a Prüfer sequence which stops when there are 2 nodes left (rather than just 1). The linked article gives an efficient pseudo-code algorithm which can be adapted by skipping the final step (linking together the last two nodes).

Answer 4

I've come up with this algorithm. It's a lot like this http://en.wikipedia.org/wiki/Pr%C3%BCfer_sequence, but like Andrew said I left the last part out of it. The hashmap is for the adjacency list and arraylist k is for the presentation.
public static HashMap<Integer, HashSet<Integer>> toGraph(ArrayList<Integer> k) {
HashMap<Integer, HashSet<Integer>> hm = new HashMap<Integer, HashSet<Integer>>();
for(int i=1; i<=k.size()+1; i++){
hm.put(i, new HashSet<Integer>());
}
int degree[] = new int[k.size()+1];
for(int i=0; i<degree.length; i++){
degree[i]=1;
}
for(int a : k){
degree[a-1]++;
}
for(int n : k){
for(int j : hm.keySet()){
if(degree[j-1]==1){
hm.get(j).add(n);
hm.get(n).add(j);
degree[n-1]--;
degree[j-1]--;
break;
}
}
}
return hm;
}
In some cases one vertex is misplaced in adjacency list returned. F.e. in 16, 1, 19, 9, 19, 18, 17, 10, 13, 13, 4, 19, 5, 19, 18, 4, 19, 19 vertex 3 should have edges to 17, 19, 13 but in mine it has edges to 16, 19, 13. Can someone spot a flaw?