【人工智能】Java实现一致代价搜索(Uniform-cost Search,UCS)

1.原理

话说BFS(Breadth-first Search,宽度优先搜索)只在每步代价一样时才是最优的,如按照结点深度来搜索,每一层其代价都是1.但是如果每步代价不一样,BFS就不是最优了,这时就要构造一个行动代价函数,这就是一致代价搜索(Uniform-cost Search,后称UCS)。UCS与BFS有两点不一样:1)目标结点检测应用于被选择扩展时,原因是第一个生成的目标结点也许是次优的。2)如果在扩展时发现有更好的路径到达目标,那将替换掉它。其实个人觉得还有第三个不同,那就是UCS使用优先级队列,而BFS使用一般队列即可。

2.示例图

 

【人工智能】Java实现一致代价搜索(Uniform-cost Search,UCS)_第1张图片

如上图,要搜索4=>6的路径,很明显4=>3=>2=>6是最短路径。(牢记优先级队列,小的排在队列前面)

  • 45:2,49:3,43:2,因4=>5路径短,故先探索结点5,故45出队,扩展结点5
  • 49:3,43:4 ,453:7 ,456:8 ,虽然找到了456路径,但456并未排在队首,49出队,扩展结点9
  • 43:4 ,493:5 ,453:7 ,456:8 ,此时43最短,将出队,扩展结点3
  • 493:5 ,432:6 ,439:6 ,453:7,456:8 ,435:9 ,493最短,出队,扩展结点3(虽然3已探索,但3不在当前路径上)
  • 432::6 ,439:6,4932:7 ,453:7 ,456:8 ,435:9 ,4935:10 ,此时432出队,扩展结点2
  • 439:6 ,453:7 ,4932:7, 4326:7 ,456:8,435:9 ,4935:10 ,4321:11 ,又找到目标路径4326,但此时有更短路径439,故439出队,扩展结点9(因9扩展后的结点为3,4,已经被探索过,且也在当前路径439上,故出队后没了)
  • 453:7 ,4326:7 ,4932:7 ,456:8 ,435:9 ,4935:10 ,4321:11,最短的453,出队,扩展3后的结点为2,4,5,9,去掉4,5,路径有4532:9、4539:9
  • 4326:7 ,4932:7,456:9 ,4532:9 ,4539:9 ,435:9 ,4935:10 ,4321:11 ,最短路径4326,出队,通过目标测试,找到路径4=>3=>2=>6,代价为7,UCS搜索结束,当然如果要再找出更多路径,可以设置一个计数器。

可以看出,为了找到最短路径,做了很多必要的搜索,因为刚开始就找到了路径456,但456不一定是最优的,故还需要扩展其他结点才能判断是否是最短的,最后找到4326路径,该路径在优先级队列里已经是最短的了,故肯定是最优的路径了(因为其他路径可能还没有结束搜索,即使结束搜索的路径也比这个大)。

3.数据结构

在上一篇文章中,我们用邻接表构造了图,这次我们使用邻接矩阵来构造该图。

1)图结构

public class Graph {
    final static int  MAXSIZE=1000;//最多1000个顶点
    String[] vertexes=new String[MAXSIZE];  //顶点数组
    int[][] edges=new int[MAXSIZE][MAXSIZE];//邻接矩阵
    int  verNum,edgeNum;//顶点个数、边条数
    public  Graph()
    {
        verNum=0;
        edgeNum=0;
    }
    public  Graph(String[] Vertexes,int[][] Edges,int VerNum,int EdgeNum)
    {
        vertexes=Vertexes;
        edges=Edges;
        verNum=VerNum;
        edgeNum=EdgeNum;
    }
}

上图的邻接矩阵见下面测试代码。

2)路径结构

路径结构比较简单:一个是路径、一个是代价

public class costPath {
    String  path;//路径,如3216
    int cost;//路径代价
    int estCost;//估计路径代价,启发函数或评估函数计算出的代价
    public  costPath(String Path)
    {
        path=Path; 
        cost=0; 
        estCost=0;
    }
    public  costPath(String Path,int Cost)
    {
        path=Path; 
        cost=Cost; 
        estCost=0;
    }
    public  costPath(String Path,int Cost,int EstCost)
    {
        path=Path; 
        cost=Cost; 
        estCost=EstCost;
    }
    public void  print()
    {
       System.out.print(path+",cost:"+cost+",estimate Cost:"+estCost+"||");
    }
}

4.输出图

    public  void print()
    {
        //输出顶点
        System.out.print("顶点:");
        for(int i=0;i0) //表示有边,为0就没有了,不考虑负值边
                   System.out.print(vertexes[i]+"=>"+vertexes[j]+":"+edges[i][j]+" ");
             System.out.println();
        }
    }

5.查找顶点对应的编号

    public  int searchVertex(String vertex)
    {
        for(int i=0;i

6.解析路径并输出对应代价

    public  void  parsePath(ArrayList path)
    {
        for(int i=0;i符号
                     System.out.print(vertexes[Integer.parseInt(realPath[j])]);
                else 
                      System.out.print("=>"+vertexes[Integer.parseInt(realPath[j])];
            }
            System.out.println(",Cost:"+subPath.cost);//输出代价
        }
    }

7.判断结点是否在当前路径字符数组

    public  boolean  isInStringArray(String[] s,int v)
    {
        for(int i=0;i

8.一致代价搜索UCS

思路:用allPath存储找到的路径(如果需要返回多个路径的话),用explored存储已探索结点,用priFrontier存储路径队列(注意UCS需要使用优先级队列)。由于使用了路径类(路径、代价),在路径类优先级队列的比较中需要重写比较器。先测试是否是目标结点,如不是再扩展该结点。

public ArrayList  ucs(int src,int dst) {
        if (src < 0 && dst < 0 && src >= verNum && dst >= verNum) return null;
        //allPath存储路径及代价
        ArrayList allPath = new ArrayList<>();
        if (src == dst) {
            allPath.add(new costPath(String.valueOf(src), 0));
            return allPath;
        }
        //重写优先级队列的比较函数
        PriorityQueue priFrontier = new PriorityQueue<>(
            new Comparator() {
                 public int compare(costPath cp1, costPath cp2) {
                     return cp1.cost - cp2.cost;
                  }
        });
        //explored存储已探索过的结点
        ArrayList explored = new ArrayList<>();
        //源结点入队,设置代价为0
        priFrontier.offer(new costPath(String.valueOf(src), 0));
        while (!priFrontier.isEmpty()) {
            //代价最小的路径出队(优先级队列嘛)
            costPath cp = priFrontier.remove();
            //p为路径
            String p = cp.path;
            //获取路径最后一个结点
            String[] pathSplit=p.split("-");//拆分路径
            int v = Integer.parseInt(pathSplit[pathSplit.length-1]);
            if (v == dst) {  //目标测试,发现目标
                allPath.add(cp);//将路径及代价添加到allPath
                //return  allPath;//如果只要最优路径直接返回退出即可
            }
            else {
                //将该结点设置为已探索
                explored.add(v);
                //下面for循环找到结点v的后继结点并做相应处理:入队、替换
                for (int i = 0; i < verNum; i++) {
                    if (edges[v][i] > 0) { //有边
                        //组合当前路径及后继结点,备用
                        String p1 = p+"-"+i;
                        //后继结点是否在当前路径上,如果是,则会形成环,将丢弃
                        boolean isInCurrentPath = isInStringArray(pathSplit,i);
                        //判断该后继结点是否未探索、或者是否不在当前路径上
                        //未探索过的肯定需要入队
                        //另外,虽然已探索过,但并不在当前路径上的结点也需入队,
                        //这样有更多备选的路径,不至于错过短的路径
                        if (explored.indexOf(i) == -1 || !isInCurrentPath)
                            //将其入队
                            priFrontier.offer(new costPath(p1, cp.cost + edges[v][i]));
                        }
                    }
                }
            }
        }
        return allPath;
    }

9.测试及结果

public class Main {

    public static void main(String[] args)
    {
        //顶点表
        String[] vers = {"c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9"};
        int[][]  edgs={     //邻接矩阵
                {0,5,0,0,0,0,0,2,0},
                {5,0,2,0,0,1,0,0,0},
                {0,2,0,4,5,0,0,0,2},
                {0,0,4,0,2,0,0,0,3},
                {0,0,5,2,0,6,0,0,0},
                {0,1,0,0,6,0,1,2,0},
                {0,0,0,0,0,1,0,3,0},
                {2,0,0,0,0,2,3,0,0},
                {0,0,2,3,0,0,0,0,0}
        };
        Graph  g=new Graph(vers,edgs,9,13);
        System.out.println("Uniform-cost Search:");
        g.parsePath1(g.ucs(g.searchVertex("c4"),g.searchVertex("c6")));
    }
}

运行结果如下:(如果ucs方法里找到目标后直接return allPath,将只会返回第一条路径,也就是最短的或最优的路径)

Uniform-cost Search:
c4=>c3=>c2=>c6,Cost:7
c4=>c5=>c6,Cost:8
c4=>c9=>c3=>c2=>c6,Cost:8
c4=>c3=>c2=>c1=>c8=>c6,Cost:15
c4=>c9=>c3=>c2=>c1=>c8=>c6,Cost:16
c4=>c3=>c2=>c1=>c8=>c7=>c6,Cost:17
c4=>c9=>c3=>c2=>c1=>c8=>c7=>c6,Cost:18

从结果可以看出,路径代价依次增加,如果代价一样,则路径深度浅的排在前面。因此,ucs是最优的

10.分析

UCS以路径代价而不是深度来扩展结点,路径代价最小的优先扩展,BFS只是UCS的一个特例,UCS是最优的,只要不存在0代价结点(我的理解,如自环),每步代价都大于一个很小的数e,那么UCS也是完备的。

假设最优路径的代价为C*,设每步代价不少于e,则最坏情况的时空复杂度为O(b^{1+|C*/e|}),其中||表示向下取整,显然比BFS要大很多,因为要探索更多小的路径。

你可能感兴趣的:(【人工智能】Java实现一致代价搜索(Uniform-cost Search,UCS))