图

最新推荐文章于 2021-06-30 11:27:04 发布
最新推荐文章于 2021-06-30 11:27:04 发布
阅读量294 收藏
点赞数
分类专栏： 算法 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunshine0_0/article/details/64127689
版权

一、无向图Graph数据类型：

import java.util.Scanner;


public class Graph
{ 
	private final int V;
	private int E;
	private Bag<Integer>[] adj;
	public	Graph(int v)
	{
		this.V = v;
		this.E = 0;
		adj = (Bag<Integer>[])new Bag[v];
		for (int i = 0; i < v; i++)
			adj[i] = new Bag<Integer>();
	}
	public Graph(In in)
	{
		this(in.readInt());
		int E = in.readInt();
		for (int i = 0; i < E; i++)
		{
			int v = in.readInt();
			int w = in.readInt();
			addEdge(v, w);
		}
		
			
		
		
	}
	public int V()
	{
		return V;
	}
	public int E()
	{
		return E;
	}
	public void addEdge(int v, int w)
	{
		adj[v].add(w);
		adj[w].add(v);
		E++;
	}
	public Iterable<Integer> adj(int v)
	{
		return adj[v];
	}
	//常见图操作
	public static int degree(Graph G, int v)
	{
		int count = 0;
		for (int w : G.adj(v)) count++;
		return count;
	}
	public static int maxDegree(Graph G)
	{
		int max = 0;
		for (int v= 0;  v < G.V(); v++)
		{
			if (degree(G,v) > max)
				max = degree(G, v);
		}
		return max;
	}
	public static double avgDgree(Graph G)
	{
		return G.E() * 2 / G.V();
	}
	public static int numberOfSelfLoops(Graph G)
	{
		int count = 0;
		for (int v = 0; v < G.V(); v++)
			for (int w : G.adj(v))
				if (v == w) count++;
		return count / 2;
	}
	
}
二、使用深度优先搜索查找图中路径： 

public class DepthFirstPaths 
{
	private boolean[] marked;
	private int[] edgTo;
	private  final int s;
	public DepthFirstPaths(Graph G, int s)
	{
		this.s = s;
		marked = new boolean[G.V()];
		edgTo = new int[G.V()];
		dfs(G, s);
	}
	private void dfs(Graph G, int v)
	{
		marked[v] = true;
		for (int w : G.adj(v))
			if (!marked[w])
			{
				edgTo[w] = v;
				dfs(G, w);
			}
	}
	public boolean hasPathTo(int v)
	{return marked[v];}
	public Iterable<Integer> pathTo(int v)
	{
		if (!hasPathTo(v)) return null;
		Stack<Integer> path = new Stack<Integer>();
		for (int x = v; x != s; x = edgTo[x])
		{
			path.push(x);
		}
		path.push(s);
		return path;
	}
}

三、使用广度搜索查找图中路径： 

public class BreadthFirstPaths 
{
	private boolean[] marked;
	private int[] edgTo;
	private  final int s;
	public BreadthFirstPaths(Graph G, int s)
	{
		this.s = s;
		marked = new boolean[G.V()];
		edgTo = new int[G.V()];
		bfs(G, s);
	}
	private void bfs(Graph G, int s)
	{
		Queue<Integer> queue = new Queue<Integer>();
		marked[s] = true;
		queue.enqueue(s);
		while (!queue.isEmpty())
		{
			int v = queue.dequeue();
			for (int w : G.adj(v))
			{
				if (!marked[w])
				{
					edgTo[w] = v;
					marked[w] = true;
					queue.enqueue(w);
				}
			}
		}
	}
	public boolean hasPathTo(int v)
	{return marked[v];}
	public Iterable<Integer> pathTo(int v)
	{
		if (!hasPathTo(v)) return null;
		Stack<Integer> path = new Stack<Integer>();
		for (int x = v; x != s; x = edgTo[x])
		{
			path.push(x);
		}
		path.push(s);
		return path;
	}
}

四、使用深度优先找出图中连通分量： 

public class CC 
{
	private boolean[] marked;
	private int[] id;
	private int count;
	public CC(Graph G)
	{
		
		marked = new boolean[G.V()];
		id = new int[G.V()];
		for (int v = 0; v < G.V(); v++)
		{
			if (!marked[v])
			{
				dfs(G, v);
				count++;
			}
		}
	}
	private void dfs(Graph G, int s)
	{
		marked[s] = true;
		id[s] = count;
		for (int v : G.adj(s))
		{
			if (!marked[v])
				dfs(G, v);
			
		}
	}
	public boolean connected(int v, int w)
	{
		return id[v] == id[w];
	}
	public int count()
	{return count;}
	public int id(int v)
	{return id[v];}
}

五、G是无环图么： 

public class Cycle 
{
	private boolean[] marked;
	private boolean hasCycle;
	public Cycle(Graph G)
	{
		marked = new boolean[G.V()];
		for (int s = 0; s < G.V(); s++)
		{
			if (!marked[s])
			{
				dfs(G, s, s);
			}
		}
	}
	private void dfs(Graph G, int v, int u)
	{
		marked[v] = true;
		for (int w : G.adj(v))
			if (!marked[w])
			{
				dfs(G, w, v);
			}
			else if (w != v) hasCycle = true;
	}
	public boolean hasCycle()
	{return hasCycle;}
	
}
六、图G是二分图么？ 

public class TwoColor
{
	private boolean[] marked;
	private boolean[] color;
	private boolean isTwoColor = true;
	public TwoColor(Graph G)
	{
		
		marked = new boolean[G.V()];
		color = new boolean[G.V()];
		for (int v = 0; v < G.V(); v++)
		{
			if (!marked[v])
			{
				dfs(G, v);
				
			}
		}
	}
	private void dfs(Graph G, int s)
	{
		marked[s] = true;
		for (int v : G.adj(s))
		{
			if (!marked[v])
			{
				color[v] = !color[s];
				dfs(G, v);
			}
			else if (color[v] == color[s]) isTwoColor = false;
		}
	}
	public boolean isTwoColor()
	{
		return isTwoColor;
	}
}

七、有向图类型：

public class Digraph
{
	private final int V;
	private int E;
	private Bag<Integer>[] adj;
	public	Digraph(int v)
	{
		this.V = v;
		this.E = 0;
		adj = (Bag<Integer>[])new Bag[v];
		for (int i = 0; i < v; i++)
			adj[i] = new Bag<Integer>();
	}
	public Digraph(In in)
	{
		this(in.readInt());
		int E = in.readInt();
		for (int i = 0; i < E; i++)
		{
			int v = in.readInt();
			int w = in.readInt();
			addEdge(v, w);
		}
		
			
		
		
	}
	public int V()
	{
		return V;
	}
	public int E()
	{
		return E;
	}
	public void addEdge(int v, int w)
	{
		adj[v].add(w);
		E++;
	}
	public Iterable<Integer> adj(int v)
	{
		return adj[v];
	}
	public Digraph reverse()
	{
		Digraph R = new Digraph(V);
		for (int v = 0; v < V; v++)
			for (int w : adj(v))
			{
				R.addEdge(w, v);
			}
			
		return R;
		
			
		
	}
	//常见图操作
	public static int degree(Graph G, int v)
	{
		int count = 0;
		for (int w : G.adj(v)) count++;
		return count;
	}
	public static int maxDegree(Graph G)
	{
		int max = 0;
		for (int v= 0;  v < G.V(); v++)
		{
			if (degree(G,v) > max)
				max = degree(G, v);
		}
		return max;
	}
	public static double avgDgree(Graph G)
	{
		return G.E() * 2 / G.V();
	}
	public static int numberOfSelfLoops(Graph G)
	{
		int count = 0;
		for (int v = 0; v < G.V(); v++)
			for (int w : G.adj(v))
				if (v == w) count++;
		return count / 2;
	}
}
八、有向图的可达性： 

public class DirectedDFS 
{
	private boolean[] marked;
	public DirectedDFS(Digraph G, int s)
	{
		marked = new boolean[G.V()];
		dfs(G, s);
	}
	public DirectedDFS(Digraph G, Iterable<Integer> sources)
	{
		marked = new boolean[G.V()];
		for (int s : sources)
			if (!marked[s])
				dfs(G, s);
	}
	private void dfs(Digraph G, int s)
	{
		marked[s] = true;
		for (int v : G.adj(s))
			if (!marked[v])
				dfs(G, v);
	}
	public boolean marked(int v)
	{
		return marked[v];
	}
	public static void main(String[] args)
	{
		Digraph G = new Digraph(new In(args[0]));
		Bag<Integer> sources = new Bag<Integer>();
		for (int i = 1; i < args.length; i++)
			sources.add(Integer.parseInt(args[i]));
		DirectedDFS reachable = new DirectedDFS(G, sources);
		for (int v = 0; v < G.V(); v++)
			if (reachable.marked(v)) StdOut.print(v + " ");
		StdOut.println();		
	}
}

九、寻找有向环：

public class DirectedCycle 
{
	private boolean[] marked;
	private boolean[] onStack;
	private Stack<Integer> cycle;
	private int[] edgeTo;
	public DirectedCycle(Digraph G)
	{
		marked = new boolean[G.V()];
		onStack = new boolean[G.V()];
		edgeTo = new int[G.V()];
		for (int v = 0; v < G.V(); v++)
			if (!marked[v])
				dfs(G, v);
	}
	private void dfs(Digraph G, int v)
	{
		marked[v] = true;
		onStack[v] = true;
		for (int w : G.adj(v))
			if (hasCycle()) return;
			else if(!marked[w])
			{
				edgeTo[w] = v;
				dfs(G, w);
			}
			else if (onStack[w])
			{
				cycle = new Stack<Integer>();
				for (int x = v; x != w; x = edgeTo[x])
					cycle.push(x);
				cycle.push(w);
				cycle.push(v);
			}
		onStack[v] = false;
	}
	public boolean hasCycle(Digraph G)
	{
		return cycle != null;
	}
	public Iterable<Integer> cycle()
	{
		return cycle;
	}
}
十、有向图基于深度优先搜索的顶点排序： 

public class DepthFirstOrder 
{
	private boolean[] marked;
	private Queue<Integer> pre;
	private Queue<Integer> post;
	private Stack<Integer> reversepost;
	public DepthFirstOrder(Digraph G)
	{
		pre = new Queue<Integer>();
		post = new Queue<Integer>();
		reversepost = new Stack<Integer>();
		marked = new boolean[G.V()];
		for (int v = 0; v < G.V(); v++)
			if (!marked[v]) dfs(G, v);
	}
	private void dfs(Digraph G, int v)
	{
		marked[v] = true;
		pre.enqueue(v);
		for (int w : G.adj(v))
			if (!marked[w]) dfs(G, w);
		post.enqueue(v);
		reversepost.push(v);
	}
	public Iterable<Integer> pre()
	{
		return pre;
	}
	public Iterable<Integer> post()
	{
		return post;
	}
	public Iterable<Integer> reversepost()
	{
		return reversepost;
	}
}
十一、拓扑排序： 

public class Topological
{
	private Iterable<Integer> order;
	public Topological(Digraph G)
	{
		DirectedCycle cyclefinder = new DirectedCycle(G);
		if (!cyclefinder.hasCycle(G))
		{
			DepthFirstOrder dfs = new DepthFirstOrder(G);
			order = dfs.reversepost();
		}
	}
	public Iterable<Integer> order()
	{
		return order;
	}
	public boolean isDAG()
	{
		return order != null;
	}
}

十二、计算强连通分量的Kosaraju算法：

public class KosarajuSCC
{
	private boolean marked[];
	private int[] id;
	private int count;
	public KosarajuSCC(Digraph G)
	{
		id = new int[G.V()];
		marked = new boolean[G.V()];
		DepthFirstOrder order = new DepthFirstOrder(G.reverse());
		for (int s : order.reversepost())
		{
			if (!marked[s])
				{dfs(G, s); count++;}
		}
	
	}
	private void dfs(Digraph G, int s)
	{
		marked[s] = true;
		id[s] = count;
		for (int v : G.adj(s))
		{
			if (!marked[v])
				dfs(G, v);
			
		}
	}
	public boolean Stronglyconnected(int v, int w)
	{
		return id[v] == id[w];
	}
	public int count()
	{return count;}
	public int id(int v)
	{return id[v];}
}

十三、顶点对的可达性： 

public class TransitiveClosure
{
	private DirectedDFS[] all;
	TransitiveClosure(Digraph G)
	{
		all = new DirectedDFS[G.V()];
		for (int v = 0; v < G.V(); v++)
		{
			all[v] = new DirectedDFS(G, v);
		}
	}
	boolean reachable(int v, int w)
	{
		return all[v].marked(w);
	}
}
十四、加权无向图数据类型： 
public class Edge implements Comparable<Edge>
{
	private final int v;
	private final int w;
	private final double weight;
	public Edge(int v, int w, double weight)
	{
		this.v = v;
		this.w = w;
		this.weight = weight;
		
	}
	public double weight()
	{
		return weight;
	}
	public int either()
	{
		return v;
	}
	public int other(int vertex)
	{
		if (vertex == v) return w;
		else  return v;
		
	}
	public int compareTo(Edge that)
	{
		if (that.weight() > this.weight()) return -1;
		else if (that.weight() < this.weight()) return 1;
		else return 0;
	}
	public String toString()
	{
		return String.format("%d-%d %.2f", v, w, weight);
	}
}


public class EdgeWeightedGraph
{
	private final int V;
	private int E;
	Bag<Edge>[] adj;
	public EdgeWeightedGraph(int v)
	{
		this.V = v;
		this.E = 0;
		adj = (Bag<Edge>[])new Bag[V];
		for (int i = 0; i < V; i++)
		{
			adj[i] = new Bag<Edge>();
		}
	}
	public EdgeWeightedGraph(In in)
	{
		this(in.readInt());
        int E = in.readInt();
        if (E < 0) throw new IllegalArgumentException("Number of edges must be nonnegative");
        for (int i = 0; i < E; i++) {
            int v = in.readInt();
            int w = in.readInt();
            double weight = in.readDouble();
            Edge e = new Edge(v, w, weight);
            addEdge(e);
        }
	}
   public int V()
   {
	 return V;
   }
   
   public int E()
   {
	   return E;
   }
   public void addEdge(Edge e)
   {
	   int v = e.either();
	   int w = e.other(v);
	   adj[v].add(e);
	   adj[w].add(e);
	   E++;
   }
   public Iterable<Edge> edges()
   {
	   Bag<Edge> b = new Bag<Edge>();
	   for (int v = 0; v < V(); v++)
	   {
		   for (Edge e : adj[v])
		   {
			   if (e.other(v) > v) b.add(e);
		   }
	   }
	   return b;
   }
}

十五、Prim最小生成树算法的延时实现：

public class LazyPrimMST 
{
	private boolean marked[];
	private Queue<Edge> mst;
	private MinPQ<Edge> pq;
	private double weight;
	
	public LazyPrimMST(EdgeWeightedGraph G)
	{
		weight = 0;
		marked = new boolean[G.V()];
		mst = new Queue<Edge>();
		pq = new MinPQ<Edge>();
		visit(G, 0);
		while (!pq.isEmpty())
		{
			Edge e = pq.delMin();
			int v = e.either();
			int w = e.other(v);
			if (marked[v] && marked[w]) continue;
			mst.enqueue(e);
			weight += e.weight();
			if (!marked[v]) visit(G, v);
			if (!marked[w]) visit(G, w);
		}
	}
	private void visit(EdgeWeightedGraph G, int v)
	{
		marked[v] = true;
		for (Edge e : G.adj[v])
			if (!marked[e.other(v)])
				pq.insert(e);
	}
	public Iterable<Edge> edges()
	{return mst;}
	public double weight()
	{
		return weight;
	}
}

十六、Prim最小生成树的即时算法： 

public class PrimMST 
{
	private boolean[] marked;
	private Edge[] edgeTo;
	private double[] distTo;
	private IndexMinPQ<Edge> pq;
	public PrimMST(EdgeWeightedGraph G)
	{
		marked = new boolean[G.V()];
		edgeTo = new Edge[G.V()];
		distTo = new double[G.V()];
		for (int v = 0; v < G.V(); v++)
			distTo[v] = Double.POSITIVE_INFINITY;
		pq = new IndexMinPQ<Edge>(G.V());
		distTo[0] = 0.0;
		pq.insert(0, 0.0);
		while(!pq.isEmpty())
		{
			visit(G, pq.delMin());
		}
	}
	private void visit(EdgeWeightedGraph G, int v)
	{
		marked[v] = true;
		for (Edge e : G.adj[v])
		{
			int w = e.other(v);
			if(marked[w]) continue;
			if (e.weight() < distTo[w])
			{
				edgeTo[w] = e;
				distTo[w] = e.weight();
				if (pq.contains(w)) pq.change(w, distTo[w]);
				else pq.insert(w, distTo[w]);
			}
		}
	}
	public Iterable<Edge> edges() {
        Queue<Edge> mst = new Queue<Edge>();
        for (int v = 0; v < edgeTo.length; v++) {
            Edge e = edgeTo[v];
            if (e != null) {
                mst.enqueue(e);
            }
        }
        return mst;
    }
	 public double weight() {
	        double weight = 0.0;
	        for (Edge e : edges())
	            weight += e.weight();
	        return weight;
	    }

}
十七、Krustal最小生成树算法： 

public class KrustalMST 
{
	private Queue<Edge> mst;
	public KrustalMST(EdgeWeightedGraph G)
	{
		mst = new Queue<Edge>();
		MinPQ<Edge> pq = new MinPQ<Edge>();
		for (Edge e : G.edges()) pq.insert(e);
		UF uf = new UF(G.V());
		while (!pq.isEmpty() && mst.size() < G.V() - 1)
		{
			Edge e = pq.delMin();
			int v = e.either();
			int w = e.other(v);
			if (uf.connected(v, w)) continue;
			uf.union(v, w);
			mst.enqueue(e);
		}
		
	}
	public Iterable<Edge> edges()
	{
		return mst;
	}
	public double weight()
	{
		double weight = 0;
		for (Edge e : edges())
		{
			weight += e.weight();
		}
		return weight;
	}
}

十八、加权有向图的数据类型： 

public class DirectedEdge
{
	private int v;
	private int w;
	private double weight;
	public DirectedEdge(int v, int w, double weight)
	{
		this.v = v;
		this.w = w;
		this.weight = weight;
	}
	public int from()
	{
		return v;
	}
	public int to()
	{
		return w;
	}
	public double weight()
	{
		return weight;
	}
	public String toString()
	{
		return String.format("%d-%d %.2f", v, w, weight);
	}
}

public class EdgeWeightedDigraph 
{
	private final int V;
	private int E;
	Bag<DirectedEdge>[] adj;
	public EdgeWeightedDigraph(int v)
	{
		this.V = v;
		this.E = 0;
		adj = (Bag<DirectedEdge>[])new Bag[V];
		for (int i = 0; i < V; i++)
		{
			adj[i] = new Bag<DirectedEdge>();
		}
	}
	public EdgeWeightedDigraph(In in)
	{
		this(in.readInt());
        int E = in.readInt();
        if (E < 0) throw new IllegalArgumentException("Number of edges must be nonnegative");
        for (int i = 0; i < E; i++) {
            int v = in.readInt();
            int w = in.readInt();
            double weight = in.readDouble();
            DirectedEdge e = new DirectedEdge(v, w, weight);
            addEdge(e);
        }
	}
   public int V()
   {
	 return V;
   }
   
   public int E()
   {
	   return E;
   }
   public void addEdge(DirectedEdge e)
   {
	   int v = e.from();
	  // int w = e.other(v);
	   adj[v].add(e);
	  // adj[w].add(e);
	   E++;
   }
   public Iterable<DirectedEdge> edges()
   {
	   Bag<DirectedEdge> b = new Bag<DirectedEdge>();
	   for (int v = 0; v < V(); v++)
	   {
		   for (DirectedEdge e : adj[v])
		   {
			   b.add(e);
		   }
	   }
	   return b;
   }
}


十九、Dijkstra最短路径算法（加权有向图/无向图 ，不支持负权重）

public class DijstraSP 
{
	private DirectedEdge[] edgeTo;
	private double[] distTo;
	private IndexMinPQ<Double> pq;
	public DijstraSP(EdgeWeightedDigraph G, int s)
	{
		edgeTo = new DirectedEdge[G.V()];
		distTo = new double[G.V()];
		pq = new IndexMinPQ<Double>(G.V());
		for (int v = 0; v < G.V(); v++)
			distTo[v] = Double.POSITIVE_INFINITY;
		distTo[s] = 0.0;
		pq.insert(s, 0.0);
		while (!pq.isEmpty())
		{
			relax(G, pq.delMin());
		}
	}
	private void relax(EdgeWeightedDigraph G, int v)
	{
		for (DirectedEdge e : G.adj[v])
		{
			int w = e.to();
			if (distTo[w] > distTo[v] + e.weight())
			{
				distTo[w] = distTo[v] + e.weight();
				edgeTo[w] = e;
				if (pq.contains(w)) pq.change(w, distTo[w]);
				else pq.insert(w, distTo[w]);
			}
		}
	}
	public double distTo(int v)
	{
		return distTo[v];
	}
	public boolean hasPathTo(int v)
	{
		return distTo[v] != Double.POSITIVE_INFINITY;
	}
	public Iterable<DirectedEdge> pathTo(int v)
	{
		if (!hasPathTo(v)) return null;
		Stack<DirectedEdge> path = new Stack<DirectedEdge>();
		for (DirectedEdge e = edgeTo[v] ; e != null; e = edgeTo[e.from()])
			path.push(e);
		return path;
	}
}
二十、加权有向无环图的最短路径算法： 

public class AcyclicSP
{
	private DirectedEdge[] edgeTo;
	private double[] distTo;
	
	public AcycliSP(EdgeWeightedDigraph G, int s)
	{
		edgeTo = new DirectedEdge[G.V()];
		distTo = new double[G.V()];
		for (int v = 0; v < G.V(); v++)
			distTo[v] = Double.POSITIVE_INFINITY;
		distTo[s] = 0.0;
		Topological top = new Topological(G);
		for (int v : top.order())
			relax(G, v);
	}
	private void relax(EdgeWeightedDigraph G, int v)
	{
		for (DirectedEdge e : G.adj[v])
		{
			int w = e.to();
			if (distTo[w] > distTo[v] + e.weight())
			{
				distTo[w] = distTo[v] + e.weight();
				edgeTo[w] = e;
				
			}
		}
	}
	public double distTo(int v)
	{
		return distTo[v];
	}
	public boolean hasPathTo(int v)
	{
		return distTo[v] != Double.POSITIVE_INFINITY;
	}
	public Iterable<DirectedEdge> pathTo(int v)
	{
		if (!hasPathTo(v)) return null;
		Stack<DirectedEdge> path = new Stack<DirectedEdge>();
		for (DirectedEdge e = edgeTo[v] ; e != null; e = edgeTo[e.from()])
			path.push(e);
		return path;
	}
}
二十一、一般加权有向图（负权重、环）的最短路径问题BellmanFord算法： 

public class BellFordmanSP 
{
	private DirectedEdge[] edgeTo;
	private double[] distTo;
	private int cost;
	private Queue<Integer> queue;
	private boolean[] onQ;
	private Iterable<DirectedEdge> cycle;
	public BellFordmanSP(EdgeWeightedDigraph G, int s)
	{
		edgeTo = new DirectedEdge[G.V()];
		distTo = new double[G.V()];
		onQ = new boolean[G.V()];
		queue = new Queue<Integer>();
		for (int v = 0; v < G.V(); v++)
			distTo[v] = Double.POSITIVE_INFINITY;
		distTo[s] = 0.0;
		queue.enqueue(s);
		onQ[s] = true;
		while (!queue.isEmpty() && !hasNegativeCycle())
		{
			int v = queue.dequeue();
			onQ[v] = false;
			relax(G, v);
		}
	}
	private void relax(EdgeWeightedDigraph G, int v)
	{
		for (DirectedEdge e : G.adj[v])
		{
			int w = e.to();
			if (distTo[w] > distTo[v] + e.weight())
			{
				distTo[w] = distTo[v] + e.weight();
				edgeTo[w] = e;
				if (!onQ[w]) queue.enqueue(w);
				onQ[w] = true;
			}
		}
		if (cost++ % G.V() == 0)
			findNegativeCycle();
	}
	private void findNegativeCycle()
	{
		int V = edgeTo.length;
		EdgeWeightedDigraph spt;
		spt = new EdgeWeightedDigraph(V);
		for (int v = 0; v < V; v++)
			if (edgeTo[v] != null)
				spt.addEdge(edgeTo[v]);
		EdgeWeightedCycleFinder cf = new EdgeWeightedCycleFinder(spt);
		cycle = cf.cycle();
		
	}
}
















爱胡椒的小白兔呢
关注
专栏目录
加权有向图问题1--单源最短路径问题（Dijkstra算法和Bellman - Ford算法）
霍淇滨的博客
12-21 828
加权有向图实现 我们实现两个类，权重边类和有向图类。有向图类中组合权重边类来实现加权有向图。 权重边类实现： public class DirectedEdge { private int v; private int w; private double weight; ...
图论02-【无权无向】-图的深度优先遍历DFS
啊枫
10-22 850
但是出栈的顺序是反过来的，2先出栈进入pre容器，最后才是1出栈进入pre容器。因为非递归使用的是的栈，把0压栈之后，0出栈并进入pre容器进行记录。如果图中存在多个联通分量，使用循环进行DFS;随后是跟0相连的顶点都入栈，入栈的顺序是。因此两种方法遍历出来的顺序会不一样。
算法（第4版） Chapter 4.1 无向图
weixin_33738555的博客
01-15 199
Algorithms Fourth EditionWritten By Robert Sedgewick & Kevin WayneTranslated By 谢路云Chapter 4 Section 1 无向图 以下内容修改自http://www.cnblogs.com/skyivb...http://www.cnblogs....
[Java]-最短路径(Dijkstra,BellmanFord,Topological算法)
renboyu010214的博客
04-08 714
最短路径 最短路径描述的是在一幅加权有向图中，从一个顶点s到任意顶点的所有路径中权重最小的一条路径 单点最短路径问题 在一幅加权有向图中，从顶点s到任意顶点v是否存在一条有向路径，如果存在，找出权重最小的那一条有向路径 最短路径树 最短路径树描述的是在一幅加权有向图中，某一顶点s到任意顶点的最短路径组成的树，这棵树的根节点是顶点s，s到树上所有子...
算法17-无环加权有向图的最短路径算法、优先级限制下的并行任务调度问题的关键路径方法
起舞的日子
04-26 743
各位读者，晚上好。 这篇博客继续介绍无环加权有向图方面的内容。里面用到的不少类都有变动，通过附件的方式补充。 本博客代码示例均来自：算法 Algorithmes Forth Edition [美] Robert Sedgewick Kevin Wayne 著 谢路云译 文章目录一、环加权有向图的最短路径算法二、优先级限制下的并行任务调度问题的关键路径方法2.1 最长路径2.2 优先级限制下的并...
C# winform 图片定位 图片相似度匹配 查询图1在图2中的位置
05-06
图片定位主要是确定一张小图片（查询图）在大图片（背景图）中的精确位置。通常，这涉及到图像特征匹配、模板匹配或基于深度学习的方法。在WinForm应用中，我们可以使用OpenCV库，这是一个强大的跨平台计算机视觉库...
C#比较图片相似度，两张图片有多少相似
12-02
在IT领域，尤其是在图像处理和计算机视觉中，比较图片相似度是一个常见的任务。C#作为.NET框架下的主要编程语言，提供了丰富的库和API来支持这样的功能。本篇将深入探讨如何使用C#来评估和比较两张图片的相似度。 ...
html实现图片轮播（含代码和注释）
最新发布
12-20
最后，在JavaScript部分，我们通过获取轮播图容器和其中的图片元素来操作轮播图。我们使用变量currentSlide来存储当前显示的图片索引，并使用setInterval函数设置了一个定时器，每隔3000毫秒（3秒）切换到下一张图片...
ThinkphpUploadPic单图片上传+多图片上传
03-27
thinkphp+单图片上传+多图片上传（ThinkphpUploadPic） ##单图片上传：使用修改后的uploadify插件 使用方法： 1、添加/Public/plugins/uploadify文件夹； 2、html：见onePic.html,主要是引入js和css文件，在js...
点击图片弹出大图效果交互
08-03
在网页设计中，点击图片弹出大图效果是一种常见的交互设计，它为用户提供了一种查看高清晰度图像的便捷方式。这种效果通常通过JavaScript（JS）实现，因为JS具有动态控制网页元素的能力，可以轻松地处理用户的点击...
图论基础知识与常见图处理算法
书忆江南的IT博客
06-30 3525
本笔记涉及代码：https://github.com/hackeryang/Algorithms-Fourth-Edition-Exercises 1.图论应用广泛，例如地图中规划最短路线、搜索引擎中的网页链接（结点为网页）、电路板上元件之间的连接、商业交易中用连接表示现金和商品在买卖方之间的转移、编译器使用图表示大型软件系统中各模块之间的关系等（结点为模块，连接为类方法之间的调用关系），如下所...
java实现图的最短路径（SP）的贝尔曼福特（Bellman-Ford）算法
小溪科技
04-05 2896
/****************************************************************************** * Compilation: javac BellmanFordSP.java * Execution: java BellmanFordSP filename.txt s * Dependencies: EdgeWei
Java学习第二十四天 图论（广度优先，深度优先，最小生成树，最短路径）二
weixin_58070636的博客
06-30 140
最短路径 Dijkstra和单源最短路径 带权图的最短路径 Dijkstra算法 不能处理负权边，不过大量应用不依赖负权边 import java.util.Arrays; public class Dijkstra { private WeightedGraph G; private int s; private int[] dis; private boolean[] visited; public Di.
用邻接表实现无向图
正在路上的专栏
02-20 1260
import java.util.LinkedList; /** * 用邻接表(其实就是前面博客实现的哈希表)实现无向图 * @author xxxu * */ public class Graph { private final int V;//顶点数目 private int E; //边的数目 private LinkedList[] adj; //邻接表(其实就是前面
算法4第4章加权有向图Dijkstra/BellmanFord最短路径算法关键路径算法讲解
cyj88jyc的专栏
06-29 1104
最短路径即从一个顶点到达另一个顶点成本最小的路径，例如利用导航软件获取从一个地方到达另一个地方的路径，顶点对应路口，边对应公路，边的权重对应经过该路段的成本,可以是时间或距离，如果有单行线，那就要考虑加权有向图。 加权有向图的数据结构实现如下 public class EdgeWeightedDigraph { private static final String NEWLINE =...
算法 练习1.3
Catcheryp的博客
09-26 647
1.3.1import java.io.IOException;import edu.princeton.cs.algs4.StdOut; public class FixedCapacityStackOfStrings { private String[] a; private int N; public FixedCapacityStackOfStrings(int ca
十八、图算法之最短路径
guanhang89的专栏
04-19 3564
最短路径 加权有向图的数据结构 Dijstra算法有向无负边 无环加权有向图中的最短路径算法 无环加权有向图中的最长路径算法 一个应用平行任务调度 优先级限制下的平行任务调度 相对最后期限下的并行任务调度 一般有向加权图的最短路径问题 基于队列的Bellman-Ford算法 套汇最短路径这里基于的是加权有向图的讨论，而且是单源最短路径问题。我们称为最短路径的结果是一棵最短路径树。给定一幅加权有向图和
有向图中的最短路径
静无需言
08-03 3328
性质：     1：图是有向的。2：并不是所有顶点都可达。3：负权会使问题边复杂。 4: 最短路径没有环。最短路径不唯一。 表示加权有向图的基本类：   package WeiDigraph; //加权由向图的边 public class DirectedEdge {     private final int v;     private final int w;  
算法 4.2节 有向图中环的判定以及Kosaraju算法实现强连通分量
firefly
04-11 244
//有向图判定 import java.util.Stack; public class DirectedCircle { private boolean[] marked; private boolean[] onStack; private int[] edgeTo; private Stack&lt;Integer&gt; circle; publ...
创建全景图片：多张图片拼接技术解析
该资源是一个关于如何编程实现将多张图片拼接成一张全景图片的程序。主要涉及图片处理和图像合并技术。 在程序中，关键的步骤是将两张图片（bmp1 和 bmp2）逐行合并。通过使用 `MergeDIB` 函数，这个过程被详细地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值