package tool;
创新互联专业为企业提供永安网站建设、永安做网站、永安网站设计、永安网站制作等企业网站建设、网页设计与制作、永安企业网站模板建站服务，10年永安做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。
import java.util.Scanner;
public class DogSuZu
{
public static void main ( String[] args )
{
Scanner input = new Scanner (System.in);
StringBuilder builder = new StringBuilder ();
System.out.println ("输入两个单词 ，空格隔开");
while (input.hasNextLine ())
{
String line = input.nextLine ();
String one = line.split ("\\s+")[0];
String two = line.split ("\\s+")[1];
int len = one.length () two.length () ? one.length () : two.length ();
String result = "";
one = builder.append (one).reverse ().toString ();
for ( int i = 0; i len; i++ )
{
if (one.charAt (i) == two.charAt (i))
{
result += one.charAt (i);
}
else
{
break;
}
}
if ("".equals (result))
{
System.out.println ("接龙不成功");
}
else
{
System.out.println (result);
}
}
}
}
package util;
import java.util.Random;
import java.util.Scanner;
public class test {
public static void main(String[] args) {
Random rnd=new Random();
Scanner in = new Scanner(System.in);
char c=0;
String yn = "";
do{
c=(char)('A'+rnd.nextInt(27)); //产生的是随机字母
System.out.println("输入C:"+c);
for (int i = 0; i 4; i++) {
System.out.println("请输入一个大写字母：");
String at = in.next();
System.out.println(at);
String a = String.valueOf(c);
if (a.equals(at)) {
System.out.println("恭喜你，猜对了！");
break;
}else {
System.out.println("你猜错了！");
}
}
System.out.println("是否继续：y/n");
yn = in.next().trim();
}while("y".equals(yn));
System.out.println("你结束了猜字母的游戏！");
}
}
//直接粘贴，复制，就能运行。
先将单词复制一份。拿你的例子说，5个单词，由于每个可以出现两次，那么最终就是10个单词。
构造图结构，你把每个单词当成一个节点，遍历所有节点，能收尾相连且不包含节点的就连一根线，做成一个有向图。
遍历整个图，找到最长的
由于你最多只有20个单词，这种方法是绝对可行的，相当于把所有可能的龙找出来并挑选最长的。
算我无聊，写了份代码，你参考下吧，输入输出我没怎么管哈
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class FindLongestDragon
{
public static void main(String args[])
{
getLongestDragon('a', "at", "touch", "cheat", "choose", "tact");
}
public static void getLongestDragon(char startChar, String ... nodesStr)
{
ListNode nodes = new ArrayListNode();
for (String nodeStr : nodesStr)
{
nodes.add(new Node(nodeStr));
nodes.add(new Node(nodeStr));
}
//遍历所有节点关系，构成图
for (Node node1 : nodes)
{
for (Node node2: nodes)
{
if (node1 != node2)
{
checkIsLink(node1, node2);
}
}
}
//遍历
for (Node node : getStartWithCharNodes(nodes, startChar))
{
Dragon dragon = new Dragon();
dragon.append(node);
dragon.findNextNode();
}
//输出所有的龙
Collections.sort(Dragon.dragons);
for (Dragon dragon : Dragon.dragons)
{
System.out.println(dragon);
}
}
//b是否能和a相连
public static void checkIsLink(Node a, Node b)
{
String nameA = a.getName();
String nameB = b.getName();
//存在包含关系
if (nameA.endsWith(nameB) || nameB.startsWith(nameA))
{
return;
}
if (getLinkStr(a, b) != null)
{
a.addChild(b);
}
}
public static String getLinkStr(Node a, Node b)
{
String nameA = a.getName();
String nameB = b.getName();
//从第二个字符开始检查是否相连
for (int i = 1, length = nameA.length(); i length; i++)
{
String linkStr = nameA.substring(i);
if (nameB.startsWith(linkStr))
{
return linkStr;
}
}
return null;
}
private static ListNode getStartWithCharNodes(ListNode list, char startChar)
{
ListNode nodes = new ArrayListNode();
int size = list.size();
for (int i = 0; i size; i+=2)
{
Node node = list.get(i);
if (node.getName().charAt(0) == startChar)
{
nodes.add(node);
}
}
return nodes;
}
}
class Dragon implements ComparableDragon
{
private ListNode nodes = new ArrayListNode();
public static ListDragon dragons = new ArrayListDragon();
public void findNextNode()
{
Node lastNode = nodes.get(nodes.size() - 1);
boolean hasNextNode = false;
for (Node nextNode : lastNode.getChildren())
{
if (!nodes.contains(nextNode))
{
hasNextNode = true;
append(nextNode);
findNextNode();
removeTail();
}
}
//找到了尽头
if (!hasNextNode)
{
Dragon copy = this.copy();
if (!dragons.contains(copy))
{
dragons.add(copy);
}
}
}
private Dragon copy()
{
Dragon dragon = new Dragon();
for (Node node : this.nodes)
dragon.append(node);
return dragon;
}
public void append(Node node)
{
nodes.add(node);
}
public void removeTail()
{
nodes.remove(nodes.size() - 1);
}
public String toString()
{
StringBuilder sb = new StringBuilder();
//展示所有的节点
String allNodeLinkStr = getAllNodeLinkStr();
sb.append(allNodeLinkStr).append(" ");
sb.append(allNodeLinkStr.length()).append(" ");
for (Node node : nodes)
{
sb.append(node.getName()).append(" ");
}
return sb.toString();
}
@Override
public int compareTo(Dragon o)
{
return o.getLength() - this.getLength();
}
public int getLength()
{
return getAllNodeLinkStr().length();
}
public String getAllNodeLinkStr()
{
StringBuilder sb = new StringBuilder();
//展示所有的节点
sb.append(nodes.get(0));
for (int i = 1, length = nodes.size(); i length; i++)
{
Node node = nodes.get(i);
sb.append(node.getName().substring(FindLongestDragon.getLinkStr(nodes.get(i - 1), node).length()));
}
return sb.toString();
}
public boolean equals(Object o)
{
if (o instanceof Dragon)
{
Dragon d = (Dragon)o;
if (d.nodes.size() == this.nodes.size())
{
int length = this.nodes.size();
for (int i = 0; i length; i++)
{
if (!d.nodes.get(i).getName().equals(this.nodes.get(i).getName()))
{
return false;
}
}
return true;
}
}
return false;
}
}
class Node
{
private ListNode children = new ArrayListNode();
private String name;
public Node(String name)
{
super();
this.name = name;
}
public ListNode getChildren()
{
return children;
}
public String getName()
{
return name;
}
public void addChild(Node e)
{
this.children.add(e);
}
public String toString()
{
return this.getName();
}
}
这种情形大多是源文件里面还有其他类定义或者内部类定义，然后编译时会有xxx.class,xxx$1.class。其他情形暂未碰到。
