Java LinkedUndirectedGraph.create方法代码示例

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testGreedy() {
  Graph<String, String> graph = LinkedUndirectedGraph.create();
  graph.createNode("A");
  graph.createNode("B");
  graph.createNode("C");
  graph.createNode("D");
  graph.connect("A", "--", "C");
  graph.connect("B", "--", "C");
  graph.connect("B", "--", "D");
  GraphColoring<String, String> coloring =
      new GreedyGraphColoring<String, String>(graph);
  assertEquals(2, coloring.color());
  validateColoring(graph);
  assertEquals("A", coloring.getPartitionSuperNode("A"));
  assertEquals("A", coloring.getPartitionSuperNode("B"));
  assertEquals("C", coloring.getPartitionSuperNode("C"));
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testFullyConnected() {
  final int count = 100;
  Graph<String, String> graph = LinkedUndirectedGraph.create();
  for (int i = 0; i < count; i++) {
    graph.createNode("Node " + i);
    for (int j = 0; j < count; j++) {
      graph.createNode("Node " + j);
      if (i != j) {
        graph.connect("Node " + i, null, "Node " + j);
      }
    }
  }
  GraphColoring<String, String> coloring =
      new GreedyGraphColoring<String, String>(graph);
  assertEquals(count, coloring.color());
  validateColoring(graph);
  for (int i = 0; i < count; i++) {
    assertEquals("Node " + i, coloring.getPartitionSuperNode("Node " + i));
  }
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testAllConnectedToOneNode() {
  final int count = 10;
  Graph<String, String> graph = LinkedUndirectedGraph.create();
  graph.createNode("Center");
  for (int i = 0; i < count; i++) {
    graph.createNode("Node " + i);
    graph.connect("Center", null, "Node " + i);
  }
  GraphColoring<String, String> coloring =
      new GreedyGraphColoring<String, String>(graph);
  assertEquals(2, coloring.color());
  validateColoring(graph);
  assertEquals("Center", coloring.getPartitionSuperNode("Center"));
  for (int i = 0; i < count; i++) {
    assertEquals("Node 0", coloring.getPartitionSuperNode("Node " + i));
  }
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testUndirectedSimple() {
  UndiGraph<String, String> graph =
      LinkedUndirectedGraph.create();
  graph.createNode("a");
  graph.createNode("b");
  graph.createNode("c");
  graph.connect("a", "--", "b");
  assertTrue(graph.hasNode("a"));
  assertTrue(graph.hasNode("b"));
  assertTrue(graph.hasNode("c"));
  assertFalse(graph.hasNode("d"));
  assertTrue(graph.isConnected("a", "b"));
  assertTrue(graph.isConnected("b", "a"));
  assertFalse(graph.isConnected("a", "c"));
  assertFalse(graph.isConnected("b", "c"));
  assertFalse(graph.isConnected("c", "a"));
  assertFalse(graph.isConnected("c", "b"));
  assertFalse(graph.isConnected("a", "a"));
  assertFalse(graph.isConnected("b", "b"));
  assertFalse(graph.isConnected("b", "c"));

  // Removal.
  graph.disconnect("a", "b");
  assertFalse(graph.isConnected("a", "b"));
  assertFalse(graph.isConnected("b", "a"));
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testUndirectedNeighbors() {
  UndiGraph<String, String> graph =
      LinkedUndirectedGraph.create();
  graph.createNode("a");
  graph.createNode("b");
  graph.createNode("c");
  graph.createNode("d");
  graph.connect("a", "-", "b");
  graph.connect("a", "--", "b");
  graph.connect("a", "---", "b");
  graph.connect("a", "-", "c");
  graph.connect("c", "-", "d");
  assertSetEquals(graph.getNeighborNodes("a"), "b", "c");
  assertSetEquals(graph.getNeighborNodes("b"), "a");
  assertSetEquals(graph.getNeighborNodes("c"), "a", "d");
  assertListCount(graph.getNeighborNodes("a"), "b", 3);

  // Removal.
  graph.disconnect("a", "b");
  assertFalse(graph.isConnected("a", "b"));
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testSimpleSubGraph() {
  UndiGraph<String, String> graph =
      LinkedUndirectedGraph.create();
  graph.createNode("a");
  graph.createNode("b");
  graph.createNode("c");
  graph.connect("a", "--", "b");

  SubGraph<String, String> subGraph = graph.newSubGraph();
  subGraph.addNode("a");
  subGraph.addNode("b");

  try {
    subGraph.addNode("d");
    fail("SubGraph should not allow add for node that is not in graph.");
  } catch (IllegalArgumentException e) {
    // exception expected
  }

  assertFalse(subGraph.isIndependentOf("a"));
  assertFalse(subGraph.isIndependentOf("b"));
  assertTrue(subGraph.isIndependentOf("c"));
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testNoEdge() {
  Graph<String, String> graph = LinkedUndirectedGraph.create();
  for (int i = 0; i < 5; i++) {
    graph.createNode("Node " + i);
    // All node with same color.
    GraphColoring<String, String> coloring =
        new GreedyGraphColoring<String, String>(graph);
    assertEquals(1, coloring.color());
    validateColoring(graph);
    for (int j = 0; j < i; j++) {
      assertEquals("Node 0", coloring.getPartitionSuperNode("Node 0"));
    }
  }
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testTwoNodesConnected() {
  Graph<String, String> graph = LinkedUndirectedGraph.create();
  graph.createNode("A");
  graph.createNode("B");
  graph.connect("A", "--", "B");
  GraphColoring<String, String> coloring =
      new GreedyGraphColoring<String, String>(graph);
  assertEquals(2, coloring.color());
  validateColoring(graph);
  assertEquals("A", coloring.getPartitionSuperNode("A"));
  assertEquals("B", coloring.getPartitionSuperNode("B"));
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testTwoFullyConnected() {
  final int count = 100;
  // A graph with two disconnected disjunct cliques.
  Graph<String, String> graph = LinkedUndirectedGraph.create();
  for (int i = 0; i < count; i++) {
    graph.createNode("Node Left " + i);
    graph.createNode("Node Right " + i);
    for (int j = 0; j < count; j++) {
      graph.createNode("Node Left " + j);
      graph.createNode("Node Right " + j);
      if (i != j) {
        graph.connect("Node Left " + i, null, "Node Left " + j);
        graph.connect("Node Right " + i, null, "Node Right " + j);
      }
    }
  }
  assertEquals(count, new GreedyGraphColoring<String, String>(graph).color());
  validateColoring(graph);

  // Connect the two cliques.
  for (int i = 0; i < count; i++) {
    graph.connect("Node Left " + i, null, "Node Right " + i);
  }
  // Think of two exactly same graph with the same coloring side by side.
  // If we circularly shift the colors of one of the graph by 1, we can
  // connect the isomorphic nodes and still have a valid coloring in the
  // resulting graph.
  assertEquals(count, new GreedyGraphColoring<String, String>(graph).color());
  validateColoring(graph);
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testUndirectedSelfLoop() {
  UndiGraph<String, String> graph =
      LinkedUndirectedGraph.create();
  graph.createNode("a");
  graph.createNode("b");
  graph.connect("a", "--", "a");
  assertTrue(graph.isConnected("a", "a"));
  assertFalse(graph.isConnected("a", "b"));
  assertFalse(graph.isConnected("b", "a"));

  // Removal.
  graph.disconnect("a", "a");
  assertFalse(graph.isConnected("a", "a"));
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testUndirectedGetFirstEdge() {
  UndiGraph<String, String> graph =
    LinkedUndirectedGraph.create();
  graph.createNode("a");
  graph.createNode("b");
  graph.createNode("c");
  graph.connect("a", "-", "b");
  assertEquals(graph.getFirstEdge("a", "b").getValue(), "-");
  assertEquals(graph.getFirstEdge("b", "a").getValue(), "-");
  assertNull(graph.getFirstEdge("a", "c"));
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testEdgeAnnotations() {
  Graph<String, String> graph = LinkedUndirectedGraph.create();
  graph.createNode("1");
  graph.createNode("2");
  graph.createNode("3");
  graph.connect("1", "a", "2");
  graph.connect("2", "b", "3");
  GraphEdge<String, String> a = graph.getEdges("1", "2").get(0);
  GraphEdge<String, String> b = graph.getEdges("2", "3").get(0);
  checkAnnotations(graph, a, b);
}
 

import com.google.javascript.jscomp.graph.LinkedUndirectedGraph; //导入方法依赖的package包/类
public void testNodeAnnotations() {
  Graph<String, String> graph = LinkedUndirectedGraph.create();
  GraphNode<String, String> a = graph.createNode("a");
  GraphNode<String, String> b = graph.createNode("b");
  checkAnnotations(graph, a, b);
}