result 배열에다 각각의 깊이우선탐색 결과를 저장해서 출력하도록하였고,
지나간 길은 lineVisited(star,end)로 하여 지나갔으면 1로 아니면 0으로 표시했습니다.
지나간 점은 pointVisited를 통하여 지나갔으면 true로 표시 되도록 했습니다.
깊이우선 탐색을 하는 방법은 일단 마지막 점은 pointVisited는 true이되 lineVisited의 start점에 없는
점을 마지막점으로 하여 거꾸로 탐색했습니다.

package test2;

import java.util.Scanner;
import java.util.Vector;

public class Main
{

public static int min(int a,int b)
{
    if(a>=b)
        return b;
    else
        return a;
}

public static boolean equalOx(Object charAt, Object charAt2) 
{
    char temp01=(char)charAt;
    char temp02=(char)charAt2;
    if(temp01==temp02)
        return true;
    else
        return false;
}

public static void main(String [] agrs) 
{
    int testCount;
    String[] result = new String[20];
    Scanner scan = new Scanner(System.in);
    testCount=scan.nextInt();
    if(testCount>50)        //테스트 케이스의수 제한
    {
        System.out.println("케이스의 수는 50이하여야 합니다.");
        return;
    }
    for(int i=0;i<testCount;i++)
    {
        Dictionary DicGraph=new Dictionary();
        int[] sameIndex=new int[20];
        int wordCount;
        wordCount=scan.nextInt();
        if(wordCount<1||wordCount>200)      //단어의 갯수 제한
        {
            System.out.println("단어의 갯수는 1이상 200 이하 입니다.");
            return; 
        }
        String word[]=new String[wordCount];
        for(int j=0;j<wordCount;j++)
        {
            word[j]=scan.next();//next()랑 nextLine()과 다르다.
            if(word[j].length()==0||word[j].length()>20)        //단어의 길이 제한
            {
                System.out.println("단어의 길이는 1이상 20이하 입니다.");
                return;
            }
        }
        for(int k=0;k<wordCount-1;k++)
        {
            int a=word[k].charAt(0)-'a';
            int b=word[k+1].charAt(0)-'a';
            if(a != b)
            {
                DicGraph.setLineVisited(a,b);
                DicGraph.setPointVisited(a);
                DicGraph.setPointVisited(b);
            }
            else
            {
                //짧은 단어의 길이만큼 돈다.
                int len=min(word[k].length(),word[k+1].length());
                for(int l=1;l<len;l++)
                {
                    int p=word[k].charAt(l)-'a';
                    int q=word[k+1].charAt(l)-'a';
                    if(equalOx((char)p,(char)q)==false)
                    {

                        DicGraph.setLineVisited(p, q);
                        DicGraph.setPointVisited(p);
                        DicGraph.setPointVisited(q);
                        break;
                    }
                }
            }
        }
        DicGraph.dfsAll();
        result[i]=DicGraph.printOrder();
    }

    for(int i=0;result[i] != null;i++)
    {
        System.out.println(result[i]);
    }

    scan.close();
}

}

class Dictionary {

private int[][] lineVisited;
private boolean[] pointVisited;
private Vector<Integer> order;

public Dictionary() 
{
    super();
    lineVisited = new int[26][26];
    pointVisited=new boolean[26];
    order=new Vector<Integer>();
    order.clear();
}

public int getLineVisited(int a,int b) 
{
    return lineVisited[a][b];
}

public void setLineVisited(int a,int b) 
{
    this.lineVisited[a][b] =1 ;
}

public boolean[] getPointVisited() 
{
    return pointVisited;
}

public void setPointVisited(int a) 
{
    this.pointVisited[a] = true;
}
public boolean Able()       //경로에 같은게 두번있는지 확인
{
    for(int i=0;i<order.size()-1;i++)
    {
        for(int j=i+1;j<order.size();j++)
        {
            if(order.elementAt(i)==order.elementAt(j))
                return false;
        }
    }
    return true;
}

public void dfs(int here)
{
    for(int i=0;i<26;i++)
    {
        if(getLineVisited(i,here)==1)
        {
            dfs(i);
            order.add(i);
        }
    }
}
void dfsAll()
{
    order.clear();
    for(int i=0;i<26;i++)
    {
        if(pointVisited[i]==true)
        {
            int j;
            for(j=0;j<26;j++)
            {
                if(getLineVisited(i,j)==1)
                    break;
            }
            if(j==26)       //맨마지막꺼 찾아내서 거꾸로 저장
            {
                dfs(i);
                order.add(i);
            }
        }
    }
}
public String printOrder()
{
    if(Able()==false||order.size()==0)
    {
        return "INVALID HYPOTHESIS";
    }
    else
    {
        int i;
        for(i=0;i<order.size()-1;i++)
        {
            if(order.get(i)>order.get(i+1))     //알파벳 순서로 되어 있다면
                break;
        }
        if(i==order.size()-1)
        {
            return "abcdefghijklmnopqrstuvwxyz";
        }
        else
        {
            String returnString="";
            for(int value:order)
                returnString += (char)(value+'a');
            for(i=0;i<26;i++)
            {
                int a;
                for(a=0;a<order.size();a++)
                {
                    if((int)order.elementAt(a)==i)
                        break;
                }
                if(a==order.size())
                    returnString += (char)(i+'a');
            }
            return returnString;
        }
    }
}

}