写一个图的算法(一)

删除图中的节点

删除6结点

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;

public class DeleteNode{
  /* static List<LinkedList<Integer>> templist; */
  static List<LinkedList<Integer>> totallist;
  static List<LinkedList<Integer>> Normallist;
public static void main(String[] args) {
  Scanner sc = new Scanner(System.in);
  
  int N = sc.nextInt();
  int M = sc.nextInt();
   totallist = new ArrayList<LinkedList<Integer>>();
   Normallist = new ArrayList<LinkedList<Integer>>();
  for(int i=0;i<N;i++) {
    totallist.add(new LinkedList<Integer>());
    Normallist.add(new LinkedList<Integer>());
  }
  for(int i=0;i<M;i++) {
    int s = sc.nextInt();
    int e = sc.nextInt();
    /* if(hasEdge(s-1,e-1))continue; */
    totallist.get(s-1).add(e-1);
    totallist.get(e-1).add(s-1);
    Normallist.get(s-1).add(e-1);
    Normallist.get(e-1).add(s-1); 
  }
  System.out.println(" ");
  List<LinkedList<Integer>> deleteNode = deleteNode(6);
  System.out.println(" ");
}
  
    private static boolean hasEdge(int i, int j) { // TODO Auto-generated method
    for(Integer m:totallist.get(i)) { if(m==j) return true; } return false;
    }
   


private static List<LinkedList<Integer>> deleteNode(int i) {
  List<LinkedList<Integer>> templist = new ArrayList<LinkedList<Integer>>(totallist);
  templist.remove(i);
  templist.add(i,new LinkedList<Integer>());
  
  for(int j=0;j<templist.size();j++) {
    LinkedList<Integer> temp = templist.get(j);
    Iterator<Integer> it = temp.iterator();
    while(it.hasNext()) {
      Integer intNum = it.next();
      if(i==intNum.intValue()) { //引用变量Integer超出255范围后==比较为false，拆箱
        it.remove(); //迭代器进行删除
      }
    }
  }
  totallist.clear();
  totallist.addAll(Normallist);
  return templist;

  //去除集合中的重复元素
  /* templist.remove(i); */
/*  for(LinkedList item:templist) {
    HashSet<Integer> hashSet = new HashSet<>(item);
    item.clear();
    item.addAll(hashSet);
  }*/
}
}

测试用例:

10 8
1 5
3 9
9 7
7 4
6 7 
10 5
10 2
8 5

输出：

并查集算法

 并查集判断两点是否相连与路径压缩

并查集常用来解决连通性的问题，即将一个图中连通的部分划分出来。当我们判断图中两个点之间是否存在路径时，就可以根据判断他们是否在一个连通区域。

并查集的思想就是，同一个连通区域内的所有点的根节点是同一个。将每个点映射成一个数字。先假设每个点的根节点就是他们自己，然后我们以此输入连通的点对，然后将其中一个点的根节点赋成另一个节点的根节点，这样这两个点所在连通区域又相互连通了。 并查集的主要操作有：

• find(int m)：这是并查集的基本操作，查找m的根节点。
• isConnected(int m,int n)：判断m，n两个点是否在一个连通区域。
• union(int m,int n):合并m，n两个点所在的连通区域。

class UnionFind {
    int[] parents;

    public UnionFind(int totalNodes) {
        parents = new int[totalNodes];
        for (int i = 0; i < totalNodes; i++) {
            parents[i] = i;
        }
    }
        // 合并连通区域是通过find来操作的, 即看这两个节点是不是在一个连通区域内.
    void union(int node1, int node2) {
        int root1 = find(node1);
        int root2 = find(node2);
        if (root1 != root2) {
            parents[root2] = root1;
        }
    }

    int find(int node) {
        while (parents[node] != node) {
            // 当前节点的父节点 指向父节点的父节点.
            // 保证一个连通区域最终的parents只有一个.
            parents[node] = parents[parents[node]];
            node = parents[node];
        }

        return node;
    }

    boolean isConnected(int node1, int node2) {
        return find(node1) == find(node2);
    }
}

典型案例：

判断没有与0相连结点的个数

测试用例:

8 7 
0 1
3 0
1 2
3 7
8 6
2 5
7 2

并查集实现

public class UF {
    static int[] parents;
    static int[] ranks;//基于高度的优化
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int M = scanner.nextInt();
        parents = new int[N+1];
        ranks = new int[N+1];
        for(int i = 0;i<N+1;i++) {
            parents[i] = i;
            ranks[i] = 1;
        }
        for(int i=0;i<M;i++){
            int s = scanner.nextInt();
            int e = scanner.nextInt();
            unionElement(s,e);
        }
        int count = 0;
        for(int i =0;i<N+1;i++) {
            if(!isConnected(0, i)) {
                count++;
            }
        }
        System.out.println(count);
    }
    private static void unionElement(int s, int e) {
        // TODO Auto-generated method stub
        int pRoot = find(s);
        int qRoot = find(e);
        if(pRoot==qRoot) return;
        if(ranks[pRoot]<ranks[qRoot]) {
            parents[pRoot] = qRoot; //高度小的节点指向高度比较高的节点
        }else if(ranks[qRoot]<ranks[pRoot]) {
            parents[qRoot] = pRoot;
        }else {
            parents[qRoot] = pRoot;
            ranks[pRoot]+=1;
        }
    }
    private static boolean isConnected(int x,int y) {
        return find(x) == find(y);
        }
    
    private static int find(int n) {
        if(n!=parents[n])
            parents[n] = find(parents[n]);//路径压缩
        return parents[n];
    }
}

输出：

3

经典案例

给定一个二维的矩阵，包含 ​​'X'​​​ 和 ​​'O'​​（字母 O）。

找到所有被 ​​'X'​​​ 围绕的区域，并将这些区域里所有的 ​​'O'​​​ 用 ​​'X'​​ 填充。

示例:

X X X X
X O O X
X X O X
X O X X

运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X

解释:

被围绕的区间不会存在于边界上，换句话说，任何边界上的 ​​'O'​​​ 都不会被填充为 ​​'X'​​​。 任何不在边界上，或不与边界上的 ​​'O'​​​ 相连的 ​​'O'​​​ 最终都会被填充为 ​​'X'​​。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

我们的思路是把所有边界上的O看做一个连通区域。遇到O就执行并查集合并操作，这样所有的O就会被分成两类

• 和边界上的O在一个连通区域内的。这些O我们保留。
• 不和边界上的O在一个连通区域内的。这些O就是被包围的，替换。

由于并查集我们一般用一维数组来记录，方便查找parants，所以我们将二维坐标用node函数转化为一维坐标。

实现

public class IsandsFind {

   static char[][] grid = {
           {'x','x','x','x'},
           {'x','0','0','x'},
           {'x','x','0','x'},
           {'x','0','x','x'}
       };
   static int[] parents;
   static int[] ranks;
   static int m;
   static int n;
    public static void main(String[] args) {
   m = grid.length;
   n = grid[0].length;
   parents = new int[m*n+1];
   ranks = new int[m*n+1];
   int dummyNode = m*n;
   for(int i=0;i<m*n+1;i++) {
      parents[i] = i;
      ranks[i] =1;
   }
   for(int i=0;i<m;i++) {
      for(int j=0;j<n;j++) {
         if(grid[i][j]=='0') {
            // 遇到O进行并查集操作合并
            if (i == 0 || i == m - 1 || j == 0 || j == n - 1) {
                    // 边界上的O,把它和dummyNode 合并成一个连通区域.
               unionElement(node(i, j), dummyNode);
                } else {
                    // 和上下左右合并成一个连通区域.
                    if (i > 0 && grid[i - 1][j] == '0')
                     unionElement(node(i, j), node(i - 1, j));
                    if (i < m - 1 && grid[i + 1][j] == '0')
                     unionElement(node(i, j), node(i + 1, j));
                    if (j > 0 && grid[i][j - 1] == '0')
                     unionElement(node(i, j), node(i, j - 1));
                    if (j < n - 1 && grid[i][j + 1] == '0')
                     unionElement(node(i, j), node(i, j + 1));
                }
         }
      }
   }
   
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (isConnected(node(i, j), dummyNode)) {
                // 和dummyNode 在一个连通区域的,那么就是O；
               grid[i][j] = '0';
            } else {
               grid[i][j] = 'x';
            }
        }
    }
    System.out.println(grid);
    }

   private static int node(int i,int j) {
      return i*n+j;
   }
   
   private static boolean isConnected(int x,int y) {
      return find(x)==find(y);
   }

   private static int find(int n) {
      // TODO Auto-generated method stub
      if(n!=parents[n])
         parents[n] = find(parents[n]);
      return parents[n];
   }
   private static void unionElement(int s,int e) {
      int pRoot = find(s);
      int qRoot = find(e);
      if(pRoot==qRoot) return;
      if(ranks[pRoot]<ranks[qRoot]) {
         parents[pRoot] = qRoot;
      }else if(ranks[qRoot]<ranks[pRoot]) {
         parents[qRoot] = pRoot;
      }else {
         parents[qRoot] = pRoot;
         ranks[pRoot]+=1;
      }
   }
}

输出：

图的遍历-深度优先搜索

DFS获取无向图中的所有路径

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

public class Path {
   private int[] form;
   private int s;
   private Graph graph;
    private boolean[] visited;
    private List<int[]> totalList;
    
   
    public Path(int s, Graph graph) {
      super();
      this.s = s;
      this.graph = graph;
      visited = new boolean[graph.V()];
      form = new int[graph.V()];
      for(int i=0;i<graph.V();i++) {
         form[i] = -1;
      }
      totalList = new ArrayList<>();
      int toIndex = 6;
      DFS(s,toIndex);
   }

   private boolean hasPath(int w) {
       return form[w]!=-1;
       //return visited[w];
   } 
   private List<List<Integer>> path(int w){
      List<List<Integer>> retlist = new ArrayList<>(); 
      for(int[] tempForm:totalList) {
         List<Integer> list = new ArrayList<>();
         Deque<Integer> deque = new LinkedList<>();
         int p = w;
         while(p!=-1) {
           deque.push(p);
           p = tempForm[p]; 
           
         }
         while(!deque.isEmpty()) {
            list.add(deque.pop());
         } 
         retlist.add(list);
      }
   return retlist;
      
   }
   //showPath(6)
   void showPath(int w) {
      assert hasPath(w);
       List<List<Integer>> path = path(w);
       for(int i=0;i<path.size();i++) {
         for(int j=0;j<path.get(i).size();j++) {
            System.out.println(path.get(i).get(j));
            if(j!=path.get(i).size()-1)
            System.out.print(" -> ");
            else
            System.out.println();
          }
       }
       
       
   }
   
   private void DFS(int i,int toIndex) {
      // TODO Auto-generated method stub
      visited[i] = true;
      if(i==toIndex) {
         visited[i] = false;
         return;
      }
      for(int item :graph.adj(i)) {
         if(!visited[item]) {
            form[item] = i;
            if(item==toIndex) {
               visited[i] = false;
               int[] temp = Arrays.copyOf(form, form.length);
               totalList.add(temp);
            }
            DFS(item,toIndex);
            //form[item] = i;
            /*if(item==toIndex) {
               int[] temp = Arrays.copyOf(form, form.length);
               totalList.add(temp);
               Arrays.fill(form, -1);
            }*/
         }  
      }
      visited[i] = false;
      form[i] = -1;
    }
}

打印输出：

DFS获取图的连通分量判断两点是否连接

深度遍历是把与i相连接的，不是相邻近的所有的节点遍历一边，没遍历的节点一定在其他的联通分量中

public class Compents {
 Graph graph;
 private boolean[] visited;
 private int count;
 private int[] ids;
public Compents(Graph graph) {
  this.graph = graph;
  int V = graph.V();
  visited = new boolean[V];
  ids = new int[V];
  count = 0;
  for(int i=0;i<V;i++) {
    ids[i] = -1;
  }
  //connect numbers 
  for(int i=0;i<V;i++) {
    if(!visited[i]) {
      DFS(i);
      count++;
    } 
  }
}
private void DFS(int i) {
  // TODO Auto-generated method stub
  visited[i] = true;
  ids[i] = count;
  for(int item :graph.adj(i)) {
    if(!visited[item])
      DFS(item);
  }
  
}
 
int count() {
  return count;
}
  
boolean isConnected(int v,int w) {
  return ids[v] == ids[w];
}
  
  
}

DFS遍历有向无环有权图任意两点间最优路径

DFS(0,7); 计算0-7所有路径中权值最小的

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;


/**
 * 13:22:38 13:26:13 13:47:39 14:52:02 13:53:51 13:55:37 14:56:52 
 * 13:57:55 14:01:08 14:02:55 14:08:10 14:11;35 14:16:18 14:17:44
 * 14:19:04 14:22:58 14:25:29 
 * @author Administrator
 *
 */
public class weighDirRoute {
  static List<List<int[]>> totallist;
  static boolean[] visited;
  static int MaxCount;
  static List<Integer> compareMax;
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int N = scanner.nextInt();
    int M = scanner.nextInt();
    totallist = new ArrayList<>();
    compareMax= new ArrayList<>();
    visited = new boolean[N];
    for(int i=0;i<N;i++) {
      totallist.add(new LinkedList<>());
    }
    for(int i=0;i<M;i++) {
      int s = scanner.nextInt();
      int e = scanner.nextInt();
      int w = scanner.nextInt();
      totallist.get(s).add(new int[]{s,e,w});
    }
    
    MaxCount = 0;
    DFS(0,7);
    Integer answer = Collections.min(compareMax);
    System.out.println(answer);
  }
  private static void DFS(int i,int toIndex) {
    // TODO Auto-generated method stub
    visited[i] = true;
    for(int[] items:totallist.get(i)) {
      int item = items[1];
      int Count = items[2];
      if(!visited[item]) {
        MaxCount+=Count;
        if(item==toIndex) {
          compareMax.add(MaxCount);
        }
        DFS(item,toIndex);
        /*if(item==toIndex) {
          compareMax.add(MaxCount);
        }*/
        MaxCount-=Count;
      }
    }
    visited[i] = false;
  }
}

输出：

DFS计算节点间能到达的最远距离

无向图

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
/**
 * @author Administrator
 * 6:52:38 6:53:51
 */
public class ND {
    static int[][] Map;
    static boolean[] visited;
    static List<LinkedList<Integer>> totalList;
    static int MaxCount;
    static int Count;
    static int N;
    static int R;
    static int C;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
         N = sc.nextInt();//点的个数
         int M = sc.nextInt();
         Map = new int[N][N];
         totalList = new ArrayList<LinkedList<Integer>>();
             for(int j=0;j<N;j++) {
               LinkedList<Integer> itemList = new LinkedList<Integer>();
               totalList.add(itemList);
             }
             
        for(int i=0;i<M;i++) {
            int startPoint = sc.nextInt();
            int endPoint = sc.nextInt();
            List<Integer> itemsList = new LinkedList<Integer>();
            itemsList.add(startPoint);
            itemsList.add(endPoint);
            totalList.get(itemsList.get(0)-1).add(itemsList.get(1)-1);
            totalList.get(itemsList.get(1)-1).add(itemsList.get(0)-1);
        }    
             
             
         MaxCount = 0;
         for(int i=0;i<N;i++) {
             visited = new boolean[N];
             Count = 0;
             if(totalList.get(i).size()>0)
             DFS(i);
         }
         
         System.out.println(MaxCount);
        
    }
    private static void DFS(int i) {
        // TODO Auto-generated method stub
        MaxCount = MaxCount>Count?MaxCount:Count;
         visited[i] = true;
         for(Integer items : totalList.get(i)) {
          if((!visited[items])) {
              Count++;
              DFS(items);
          }
         }
         return;
    }

}

输出:

有向图

public class DirectGraph {
    static int[][] Map;
    static boolean[] visited;
    static List<LinkedList<Integer>> totalList;
    static int MaxCount;
    static int Count;
    static int N;
    static int R;
    static int C;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
         N = sc.nextInt();//点的个数
         int M = sc.nextInt();
         Map = new int[N][N];
         totalList = new ArrayList<LinkedList<Integer>>();
             for(int j=0;j<N;j++) {
               LinkedList<Integer> itemList = new LinkedList<Integer>();
               totalList.add(itemList);
             }
             
        for(int i=0;i<M;i++) {
            int startPoint = sc.nextInt();
            int endPoint = sc.nextInt();
            /*List<Integer> itemsList = new LinkedList<Integer>();
            itemsList.add(startPoint);
            itemsList.add(endPoint);*/
            totalList.get(startPoint-1).add(endPoint-1);
            //totalList.get(itemsList.get(1)-1).add(itemsList.get(0)-1);
        }    
             
             
         MaxCount = 0;
         for(int i=0;i<N;i++) {
             visited = new boolean[N];
             Count = 0;
             if(totalList.get(i).size()>0)
             DFS(i);
         }
         
         System.out.println(MaxCount);
        
    }
    private static void DFS(int i) {
        // TODO Auto-generated method stub
        MaxCount = MaxCount>Count?MaxCount:Count;
         visited[i] = true;
         for(Integer items : totalList.get(i)) {
          if((!visited[items])) {
              Count++;
              DFS(items);
              //Count--;
          }
         }
         Count--;
         return;
    }

}

输出:

2

有向图要--

图的遍历-广度优先搜索

广度优先计算无向图的最短路径

广度优先搜索算法（Breadth-First-Search），是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树(图)的宽度遍历树(图)的节点。如果所有节点均被访问，则算法中止。BFS同样属于盲目搜索。一般用队列数据结构来辅助实现BFS算法。

算法步骤：

1. 首先将根节点放入队列中。

2. 从队列中取出第一个节点，并检验它是否为目标。

如果找到目标，则结束搜寻并回传结果。

否则将它所有尚未检验过的直接子节点加入队列中。

3. 若队列为空，表示整张图都检查过了——亦即图中没有欲搜寻的目标。结束搜寻并回传"找不到目标"。

4. 重复步骤2。

广度一次将一个图的相邻节点全部遍历，然后遍历相邻节点的相邻节点，需要使用队列作为辅助的数据结构

计算0-6的最短路径

广度优先求最短路径

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class ShortestPath {
  private Graph graph;
  private boolean[] visited;
  private int s;
  private int[] form;
  private int[] ords;
  public ShortestPath(Graph graph, int s) {
    super();
    this.graph = graph;
    this.s = s;
    int V = graph.V();
    visited = new boolean[V];
    form = new int[V];
    ords = new int[V];
      Arrays.fill(form, -1);
      Arrays.fill(ords, -1);
      
      Queue<Integer> queue = new LinkedList<>();
      queue.add(s);
      ords[s] = 0;
      visited[s] = true;
      while(!queue.isEmpty()) {
        Integer top = queue.poll();
        for(int item:graph.adj(top)) {
          if(!visited[item]) {
            queue.add(item);
            visited[item] = true;
            form[item] = top;
            ords[item] = ords[top]+1;
          }
        }
      }
  }
  
  public boolean hasPath(int w) {
    return visited[w];
  }
  
  public List<Integer> path(int w){
    assert hasPath(w);
    List<Integer> list = new ArrayList<>();
      Deque<Integer> deque = new LinkedList<>();
      
     int p = w;
     while(p!=-1) {
       deque.push(p);
       p = form[p];
     }
      
     while(!deque.isEmpty()) {
       list.add(deque.pop());
     }
    return list;
  }
  
  public void showPath(int w) {
    assert hasPath(w);
    
    List<Integer> path = path(w);
    for(int i=0;i<path.size();i++) {
      System.out.println(path.get(i));  
      if(i==path.size()-1) {
        System.out.println();
      }else {
        System.out.print("->");
      }
    }
  }

}

输出：

ords距离0结点的距离

form计算从那个结点过来的，用于输出路径