El problema es que al corre mi codigo (el que esta abajo), al colocar los valores que me piden en prueba me sale.
Exception in thread "main" java.lang.NullPointerException
at Grafo.fusion(Grafo.java:189)
at Grafo.coloreo(Grafo.java:179)
at Grafo.coloreo(Grafo.java:176)
at Grafo.coloreo(Grafo.java:176)
at Prueba.main(Prueba.java:17)

no se si alguein me puede ayudar.....

import java.io.*;
public class Global{
//public static Console c=new Console();
public static BufferedReader b=new BufferedReader(new InputStreamReader(System.in));
}


import java.io.*;
import java.util.*;
public class Grafo {
protected int numvertices;
protected int numlados;
protected boolean dirigido;
protected ListaLados adjlist [];
Vector secuencia; // vector que nos dara la secuencia a seguir para colorear el grafo
String[]color;//array que nos dara los colores con los que se pintaron cada nodo
boolean fusion[][];// array de doble dimensión el cual nos dira que vertices se fusionaron
int o=0;//contador para el array de colores
int w=0;//contador para las veces que se eliminan nodos
int f=0;//nos dara la cantidad de colores necesaria para realizar nuestro coloreo
public Grafo() {};

public Grafo(int n) {
numvertices = n;
dirigido=false;
adjlist = new ListaLados [n];
color=new String[n];
secuencia =new Vector (n);
fusion=new boolean[n][n];

}

public Grafo(int n, boolean esdirigido) {
numvertices = n;
dirigido=true;
adjlist = new ListaLados [n];
color=new String[n];
secuencia =new Vector (n);
fusion=new boolean[n][n];
}
public void agregarLado(int x, int y) {

ListaLados curr = new ListaLados(x,y);
curr.next = adjlist[x];
adjlist[x] = curr;
if (!dirigido)
{
curr = new ListaLados(y, x);


adjlist[y]=curr;
}
}
public void remove(ListaLados urr){// remueve un nodo de una lista

while(urr.next!=null && urr.next.y!=urr.y){
urr=urr.next;
if(urr.next!=null){
urr.next=urr.next.next;
}
}
}
public void imprimir(){
System.out.println("El gráfico tiene "+numvertices+" vertices");
System.out.println("El gráfico es " + (dirigido ? "dirigido" : "no dirigido"));
for (int i=0; i<numvertices; i++) {mostrar_lados(i); }
}

public void mostrar_lados(int x) {
ListaLados curr;
curr=adjlist[x];
while (curr!=null)
{
System.out.println("("+curr.x+","+curr.y+")");
curr=curr.next;
}
}
public int grado(int x) {// devuelve el grado de un vertice
ListaLados curr;
curr=adjlist[x];
int j=0;
while (curr != null)
{
for(int y=0; y< numvertices; y++ ){
if(curr.y==y)j++;
}
curr=curr.next;
}
return j;
}

public void color(){// muestra los vertices , con el respectivo color con el que fueron coloreados
for(int y=0;y<color.length;y++)
System.out.println(color[y]+ "vertices coloreados de color"+y);
}

public void coloreo(int n, Grafo e) { //coloreamos el grafo, segun el n que nos ponga(esto nos da el tope, el grado de algun vertice debe ser menor a este n para apoder realizar el algoritmo)
f=n;
boolean flag=true;
int g=0;
int verticemenor=0;
for(int s=0; s<e.numvertices;s++){
g=grado(s);
if(g<f){
f=g;
verticemenor = s;//si es que hay algun nodo con grado menor a n se almacena en vertice menor
}
}
if(f<n){// si es que hubo algun vertice menor entra
secuencia.addElement(String.valueOf(verticemenor));// guardamos el vertice menor en el vector secuencia
w++;//sumamos el contador para eliminar los nodos
if(w==e.numvertices){// si el contador llega a ser numvertices es decir ya todos los vertices estan en el vector secuencia
for(w=e.numvertices-1;w>=0;w--){
color[o]=(String)(secuencia.elementAt(w));// coloreamos el color en la posicion w del vector con el color correspondiente
for(int s=0;s<e.numvertices;s++){
if(esLado(w,s)==false){ // si el vertice que acabamos de colorear no esta unido con otro, hay la posibilidad de colorearlo del mismo color
int h=0; // este contado nos dira si podemos o no colorearlo del mismo color
int split = color[o].indexOf(",");
if( esLado(Integer.parseInt(color[o].substring(0,split)),s)==false){//vemos si es que no tieen lado comun con el primero de los vertices ya coloreados
int split2;
for(;split!=0;split=color[o].indexOf(",",split+1)){
split2=color[o].indexOf(",",split+1);
if(esLado(Integer.parseInt(color[o].substring(split,split2)),s))// vemos si es que no tiene lado en comun con otros vertices del mismo color, de lo contrario h aumenta
h++;

}
}
else h++;// si tenia un lado comun con el primero esta condición se cumple
if(h==0){
color[o]=color[o]+","+String.valueOf(s);// de no tener ningun lado en comun con ninguno de los lados ya coloreados con este color, lo coloreamos con el mismo color
for(int l=0;l<secuencia.size();l++){
if(((secuencia.elementAt(l)).equals(String.valueOf(s)))){
secuencia.removeElementAt(l);// una vez coloreado, lo removemos del vector para no volver a tratar de colorearlo
w--;// como hemos quitado un elemento degradamos nuestro contador
}
}
}


}
o++;//cambiamos nuestro color
}
}
for (int i=0;i<fusion.length;i++){// si es que se realizo una funsion, estas instrucciones se cumpliran
for (int j=0;j<fusion[i].length;j++){
if(fusion[i][j]){
int t=0;
int split = color[t].indexOf(",");
if( Integer.parseInt(color[t].substring(0,split))==i){
color[o]=color[o]+","+String.valueOf(j);
for(;t<color.length;t++){
int split2;
for(;split!=0;split=color[t].indexOf(",",split+1)){
split2=color[t].indexOf(",",split+1);
if( Integer.parseInt(color[t].substring(split,split2))==i){
color[o]=color[o]+","+String.valueOf(j);
}
}
}
}
}
}
}
color();// finalmente teniendo en cuenta la fusion y el coloreo, se imprimiran los vertices con su respectivo color.
flag=false;// cambiamos el flag para no entra en bucle infinito
}
if(flag){// siempre que no halla acabado el coloreo entrar en el if
for(int k=0; k<numvertices; k++){
ListaLados curr= adjlist[k];
if((k!=verticemenor)){// si es que el vertice menor(vertice que vamos a eliminar), no es el vertice que dictamina esta parte del array entra en el if
while (curr != null)
{
if(curr.y==verticemenor)remove(adjlist[k]);// si es que es alguno de los vertices de la lista enlazada lo eliminamos
curr=curr.next;
}


}
else
adjlist[k]=null;// de ser alguno de los vertices del array lo eliminamos
}
coloreo(f,e);// regresamos al coloreo con el nuevo grafo(eliminado verticemenor)
}
}
else fusion(e);// si es que el algoritmo no se puede realizar(no existe un vertice con grado menor al n)procedemos a la fusion
}
public void fusion(Grafo e) {
ListaLados base;// tomamos una listalados base
ListaLados siguiente;// tomamos las listalados siguiente
for(int y=0; y<numvertices;y++){
base=e.adjlist[y];//inicializamos base con adjlist [y]
siguiente=e.adjlist[y+1];// incializamos siguiente con adjlist[y+1]
int p=0;// contador que nos permitira la funsion
for(int u=0;u<=e.numvertices;u++){
if(esLado(base.x,u)&& esLado(siguiente.x,u)){// si ambos vertices tiene vertices en comun p aumentara
p++;
if(p==3){// si p es 3 osea hay 3 vertices comunes entre ambos vertices se procede a fusionar
for(int t=0;t<e.numvertices;t++){
if(esLado(base.x,t)==false && esLado(siguiente.x,t)){// para esto vemos si el vertice que vamos a fusionar tiene mas vertices unidos,(a parte de los que se tieen en comun), de ser asi los agregamos a uno de ellos
agregarLado(e.adjlist[y].x,t);
fusion[y][y+1]=true;// agregamos nuestra fusion al array doble, para poder guardar la fusion
e.adjlist[y+1]=null; //eliminamos uno de los nodos
coloreo(f,e);// volvemos al coloreo, por si ya se puede aplicar el algoritmo, caso contrario volvera a la fusion
}
}
}
}
}
}
}


public boolean esLado(int x,int y) {
ListaLados curr;
curr=adjlist[x];
while (curr != null)
{
if(curr.y==y)return true;
curr=curr.next;
}
return false;
}

public void read() throws IOException{
String line, first, second;
int x, y, split;

while (true) {
// get next line of input -- containts two ints split by a " "
line = Global.b.readLine();
if (line.equals("")){
imprimir();
break;
}
else{
// find where the split is
split = line.indexOf(",");
// extract out the numbers and convert to integer
first = line.substring(0,split);
second= line.substring(split+1);
x = Integer.parseInt(first);
y = Integer.parseInt(second);
agregarLado(x,y);}
}}
}


public class ListaLados {
//programas ListaLados y Grafo
//desarrollados por S. Hazelhurst, 2003
int x, y;
ListaLados next;


public ListaLados () {
// default constructor
}


public ListaLados(int u, int v) {
// Constructor that makes an edge list of exactly one edge
x = u;
y = v;
next = null;
}

}

import java.io.*;
public class Prueba {

/**
* @param args
*/
public static void main(String[] args) throws IOException{
// TODO Auto-generated method stub
int numv;
System.out.println("Ingrese dimensiones del grafo ");
numv=Integer.parseInt(Global.b.readLine());
Grafo g=new Grafo(numv);
g.read();
System.out.println("Ingrese colores necesarios para el grafo ");
int n=Integer.parseInt(Global.b.readLine());
g.coloreo(n,g);
g.color();
}
}

Te dice que la variable esta a null tienes que hacerle un new