Lý thuyết đồ thị code lý thuyết đồ thị

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
public abstract class Graphs {
int numvext;
int[][] maxtrix;
int v;
public Graphs(int numvext, int[][] maxtrix) {
super();
this.numvext = numvext;
this.maxtrix = maxtrix;
}


public int getNumvext() {
return numvext;
}
public void setNumvext(int numvext) {
this.numvext = numvext;
}
public int[][] getMaxtrix() {
return maxtrix;

}
public Graphs(String file) {
load(file);
}
public void load(String pATH) {
// TODO Auto-generated method stub
File file = new File(pATH);
FileReader rd;
try {
rd = new FileReader(file);
BufferedReader bufferedReader = new BufferedReader(rd);
numvext = Integer.parseInt(bufferedReader.readLine());


maxtrix = new int[numvext][numvext];
int rows = 0;
String line = "";
while ((line = bufferedReader.readLine()) != null) {
String[] strings = line.split("\\s");
for (int i = 0; i < strings.length; i++) {
maxtrix[rows][i] = Integer.valueOf(strings[i]);
}
rows++;
}
} catch (NumberFormatException | IOException e) {
// TODO: handle exception
System.out.println("error!!");
}
}
public void printmatrix(int[][] array) {

for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println("\n");


}
}
public abstract int numVertexs();
public abstract int numEdges();
// KIEM TRA DO THI DO CO HOP LI KHONG
public boolean checkValid(int[][] matrix) {
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++) {
if (matrix[i][j] == 0 && i == j) {
return true;
} else {
return false;
}
}
}
return false;
}
// KIEM TRA DO THI DO VO HUONG HAY CO HUONG


public boolean checkUnGraph(int[][] matrix) {
for (int i = 0; i < numvext; i++) {
for (int j = 0; j < numvext; j++) {

if (matrix[i][j] == matrix[j][i]) {
return true;
}
}
}
return false;
}
// tong bac cua moi dinh
public abstract int deg(int v);
// tinh tong bac do thi
public abstract int sumDeg(int v);
// implement code
// xet inh lien thong cua do thi
public void diTimcacDinhLienThong(int[][] matrixAdj, int[] arr, int v)
{
for (int i = 0; i < numvext; i++) {
if (matrixAdj[v][i] != 0 && arr[v] != arr[i]) {
arr[i] = arr[v];


diTimcacDinhLienThong(matrixAdj, arr, i);
}
}
}
// xet tinh lien thong cua do thi
public int soThanphanlienthong() {
int[] index = new int[numvext];
int stplt = 0;
for (int i = 0; i < numvext; i++) {
index[i] = 0;

}
for (int i = 0; i < numvext; i++) {
if (index[i] == 0) {
stplt++;
index[i] = stplt;
}
if (index[i] != 0) {
diTimcacDinhLienThong(maxtrix, index, i);
}
}
return stplt;
}


// xet inh lien thong cua do thi
public void xetTinhLienThong(int[][] matrixAdj) {
// implement code
int[] index = new int[numvext];// tao mang luu tru cac dinh
int stplt = 0;
for (int i = 0; i < numvext; i++) {// xet het tat ca dinh
index[i] = 0;// gan voi 0 chon dinh bat ki vieng tham
}
for (int i = 0; i < numvext; i++) {
if (index[i] == 0) {
stplt++;// so thanh phan no se tang len
index[i] = stplt;// da nh dau diem nay da dc vieng
tham
}
if (index[i] != 0) {
diTimcacDinhLienThong(matrixAdj, index, i);

}
System.out.print("So thanh phan lien thong :" + "\t" + stplt
+ "\t");
for (int j = 1; j <= stplt; j++) {
System.out.print("Cac dinh thuoc thah phan lien
thong :" + i + "\t");
for (int j2 = 0; j2 < numvext; j2++) {
if (index[j2] == j) {


System.out.print((j2 + 1) + "\t");
}
}
System.out.println();
}
}
}
// duyet do thi bang BFS
public int[] DFSGraph(int[][] matrix, int startVex) {
// implement code
int[] result = new int[numvext];
boolean[] visited = new boolean[numvext];
for (int i = 0; i < visited.length; i++) {
visited[i] = false;
}
Stack<Integer> stack = new Stack<Integer>();
stack.push(startVex);
int index = 0;
while (!stack.isEmpty()) {
int tem = stack.pop();

if (visited[tem] == false) {
visited[tem] = true;
result[index] = tem;


index++;
}
for (int i = 0; i < visited.length; i++) {
if (matrix[tem][i] != 0 && visited[i] == false) {
stack.push(i);
}
}
}
System.out.println(Arrays.toString(result));
return result;
}
// DFS
public int[] DFSGraph(int[][] matrix) {
// implement code
int[] result = new int[numvext];
boolean[] visited = new boolean[numvext];
for (int i = 0; i < visited.length; i++) {
visited[i] = false;
}
Stack<Integer> stack = new Stack<Integer>();
stack.push(v);
int index = 0;
while (!stack.isEmpty()) {

int tem = stack.pop();
if (visited[tem] == false) {
visited[tem] = true;
result[index] = tem;
index++;
}
for (int i = numvext - 1; i >= 0; i--) {
if (matrix[tem][i] != 0 && visited[i] == false) {
stack.push(i);
}
}
}
System.out.println(Arrays.toString(result));
return result;
}
// implement code
public abstract void addEdge(int[][] matrix, int v1, int v2);
// DUYET DO THI BANG DFS
public int[] BFSGraph(int[][] matrix, int v) {
// implement
int[] result = new int[numvext];
boolean[] visited = new boolean[numvext];


for (int i = 0; i < visited.length; i++) {
visited[i] = false;
}
Queue<Integer> q = new LinkedList<Integer>();
q.offer(v);
int index = 0;

while (!q.isEmpty()) {
int tem = q.poll();
if (visited[tem] == false) {
visited[tem] = true;
result[index] = tem;
index++;
}
for (int i = 0; i < visited.length; i++) {
if (matrix[tem][i] != 0 && visited[i] == false) {
q.offer(i);
}
}
}
System.out.println(Arrays.toString(result));
return result;
}
public int[] BFSGraph(int[][] matrix) {


// implement code
int[] result = new int[numvext];
boolean[] visited = new boolean[numvext];
for (int i = 0; i < visited.length; i++) {
visited[i] = false;
}
Queue<Integer> q = new LinkedList<Integer>();
q.offer(v);
int index = 0;
while (!q.isEmpty()) {
int tem = q.poll();

if (visited[tem] == false) {
visited[tem] = true;
result[index] = tem;
index++;
}
for (int i = 0; i < visited.length; i++) {
if (matrix[tem][i] != 0 && visited[i] == false) {
q.offer(i);
}
}
}
System.out.println(Arrays.toString(result));
return result;


}
// XOA CANH
public abstract void removeEdge(int[][] matrix, int v1, int v2); //
implement code
// KIEM TRA DO THI CO LIEN THONG
public boolean isConnected(int[][] matrix) {
// implement code
int[] result = new int[numvext];
boolean[] visited = new boolean[numvext];
for (int i = 0; i < visited.length; i++) {
visited[i] = false;
}
Stack<Integer> stack = new Stack<Integer>();
stack.push(v);
int index = 0;

while (!stack.isEmpty()) {
int tem = stack.pop();
if (visited[tem] == false) {
visited[tem] = true;
result[index] = tem;
index++;
}
for (int i = 0; i < visited.length; i++) {


if (maxtrix[tem][i] != 0 && visited[i] == false) {
stack.push(i);
}
for (int j = 0; j < visited.length; j++) {
if (!visited[j]) {
return false;
} else {
return true;
}
}
}
}
return false;
}
// TIM DUONG DI GIUA HAI DINH DI TU S DEN T
public void findPathTwoVexs(int[][] matrix, int s, int t) {
// implement code
ArrayList<Integer> arrayList = new ArrayList<>();// tao mot arr
luu tru duong di
int[] result = new int[numvext];

Stack<Integer> stack = new Stack<>();


arrayList.add(s);
result[s] = 1;
stack.push(s);
while (!stack.isEmpty()) {
s = stack.peek();
int count = 0;
if (s == t) {// kiem tra xem duong di tu s den t co bang nhau
k neu ma bang thi dung lại
break;
}
for (int i = 0; i < result.length; i++) {
if (matrix[s][i] > 0 && result[i] != 1) {
result[i] = 1;
arrayList.add(i);
stack.add(i);
break;
} else {
count++;
}
if (count == result.length) {
stack.pop();
}
}
System.out.println(arrayList);
}

}
public boolean check(int[][] matrix, int u) {
int[] result = new int[numvext];
Stack<Integer> stack = new Stack<Integer>();
stack.push(u);
result[u] = 0;
while (!stack.isEmpty()) {
int tem = stack.pop();
for (int i = 0; i < numvext; i++) {
if (result[i] == -1) {
result[i] = 1 - result[tem];
} else {
if (result[i] == result[tem]) {
return false;
} else {
return true;
}
}
}
}
return false;
}


// KIEMT TRA DO THI CO LIEN THONG KHONG
public abstract boolean isConnected1(int[][] matrix);
public abstract void DFSRe(int v, boolean[] visted);
// kiem tra co chu trinh k
public abstract boolean checkCycleEluer(int[][] matrix);
public abstract boolean isHalfEluerGraph(int[][] matrix);

// TIM CHU TRINH ELUER
public abstract void findEulerCycle(int[][] matrix);
public abstract boolean isUlerGraph();
// tinh bac chan
public abstract int count();
// tinh bac le
public abstract int sothple();
// tinh dinh bac 1
public abstract int count1(int[][] matrix);


public abstract int coutIshamiton();
// tinh dinh bac 2
public abstract int count2(int[][] matrix);
public abstract int countless(int[][] matrix);
// kiem tra co chu trinh hamilton
public abstract boolean KiemtraIshamition(int[][] matrix);
// tim chu trinh hamilaton
public abstract void hamCycle(int graph[][]);
// tim duong di hamilton
public abstract void HamiltonPath(int[][] x);
// tim cay bao trum bang DFS
public int[][] SpanningTree(int[][] matrix, int v) {
if (isConnected1(matrix) == false) {
return null;
}
int[][] tree = new int[numvext][numvext];
boolean[] viest = new boolean[numvext];

tree = visetDFS(v, matrix, viest);
return tree;
}
// DUYET CAY BAO TRUM BANG DFS
int[][] visetDFS(int v, int[][] matrix, boolean[] visted) {
// TODO Auto-generated method stub
int[][] tree = new int[numvext][numvext];
for (int i = 0; i < numvext; i++) {
if (matrix[v][i] != 0 && visted[i] == false) {
addEdge(tree, v, i);
visted[i] = true;
System.out.println((v + 1) + "----->" + (i + 1));
visetDFS(i, matrix, visted);
}
}
return tree;
}// TIM CAY BAO TRUM BFS
public int[][] SpanningBFS(int[][] matrix, int v) {
if (isConnected1(matrix) == false) {


return null;
} else {
int[][] tree = new int[numvext][numvext];
Queue<Integer> queue = new LinkedList<Integer>();
boolean[] viest = new boolean[numvext];
viest[v] = true;
queue.add(v);
while (!queue.isEmpty()) {
int temp = queue.poll();

for (int i = 0; i < numvext; i++) {
if (matrix[temp][i] != 0 && viest[i] == false) {
viest[i] = true;
queue.add(i);
addEdge(matrix, temp, v);
System.out.println((temp + 1) + "------->" + (i + 1));
}
}
return tree;
}
}
return matrix;
}


public int[][] SpanningTreeByDFS(int[][] matrix, int v) {
// implement code
if (isConnected1(matrix) == false) {
return null;
} else {
int[][] tree = new int[numvext][numvext];
Stack<Integer> stack = new Stack<Integer>();
boolean[] viest = new boolean[numvext];
viest[v] = true;
stack.push(v);
while (!stack.isEmpty()) {
int temp = stack.pop();
for (int i = 0; i < numvext; i++) {
if (matrix[temp][i] != 0 && viest[i] == false) {
viest[i] = true;

stack.push(i);
addEdge(matrix, temp, v);
System.out.println((temp + 1) + "------->" + (i + 1));
}
}
return tree;
}


}
return matrix;
}
public boolean checkCycle1(int[][] matrix, int v1, int v2) {
// implement code
boolean[] visetd = new boolean[numvext];
for (int i = 0; i < numvext; i++) {
visetd[i] = false;
}
Queue<Integer> queue = new LinkedList<>();
queue.add(v1);
visetd[v1] = true;
while (!queue.isEmpty()) {
int temp = queue.remove();
for (int i = 0; i < numvext; i++) {
if (matrix[temp][i] != 0 && visetd[i] == false) {
visetd[i] = true;
queue.add(i);
if (i == v2) {
return true;
}

return false;


}
}
}
return false;
}
// TIM CAY BAO TRUM NHO NHAT KRUSKAL đồ thị có hướng
public int[][] SpanningTreeByKruskal(int[][] matrix) {
// implement code
int total = 0;
int nofedg = 0;
int[][] tree = new int[matrix.length][matrix.length];
ArrayList<Edges> arrayList = new ArrayList<Edges>();
for (int i = 0; i < numvext; i++) {
for (int j = 0; j < numvext; j++) {
if (matrix[i][j] > 0) {
arrayList.add(new Edges(i, j, matrix[i][j]));
}
Collections.sort(arrayList, new
Comparator<Edges>() {
@Override
public int compare(Edges o1, Edges o2) {
// TODO Auto-generated method stub
return o1.w - o2.w;


}
});

}
for (int j = 0; j < arrayList.size(); j++) {
Edges e = arrayList.get(j);
System.out.println("canh :" + e.x + "-->" + e.y + "="
+ e.w + "\n");
}
while (nofedg < numvext - 1) {
for (int j = 0; j < arrayList.size(); j++) {
Edges e = arrayList.get(j);
if (checkCycle1(tree, e.x, e.y) == false) {
addweight(tree, e.x, e.y, e.w);
total += e.w;
nofedg++;
}
}
}


}
System.out.println("Tong :" + total);
return tree;
}
private void addweight(int[][] tree, int x, int y, int w) {
// TODO Auto-generated method stub
tree[x][y] = tree[y][x] = w;
}
// SAP XEP TRONG SO G
public List<Edges> list() {
ArrayList<Edges> arrayList = new ArrayList<Edges>();
for (int i = 0; i < maxtrix.length; i++) {

for (int j = 0; j < maxtrix.length; j++) {
if (maxtrix[i][j] != 0) {
arrayList.add(new Edges(i, j, maxtrix[i][j]));
}
Comparator<Edges> comparator = new
Comparator<Edges>() {
@Override
public int compare(Edges o1, Edges o2) {
// TODO Auto-generated method stub