n*n矩阵，输出矩阵中任意两点之间所有路径

于 2024-08-27 22:51:11 发布
阅读量292 收藏 3
点赞数 10
分类专栏： 面试后诸葛亮 - 矩阵 文章标签： 矩阵 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnm_1314/article/details/141598225
版权

题目1：给你一个正整数n， 构造一个n*n的四项链表矩阵。

             要求： 使用四项链表

                         矩阵从左到右，从上到下值依次为1,2,3,4,......n*n

题目2：基于题目1， 在n*n链表矩阵中，输出矩阵中任意两点之间所有路径。

             要求： 不能使用全局变量

                         方法只接收两个参数，分别为起始节点

构造一个n*n的四项链表矩阵

思路： 要构建一个n*n的矩阵，有这个一个简单思路：

  1. 初始化i=0
  2. 先构建第i行，第i列链表
  3. 再构建(n-1)*(n-1)矩阵
  4. 将第二步链表与第三步矩阵连接起来
  5. i=i+1
  6. 重复第二步

/**
 * @param k 当前要构造K*K矩阵
 * @param n
 * @return
 */
public Node<E> build(int k, int n) {
    if (k <= 0) {
        return null;
    }
    Node<E> head = new Node();
    // 右侧
    Node<E> r = head;
    int i = k - 1;
    while (i > 0) {
        Node<E> right = new Node();
        r.right = right;
        right.left = r;
        r = right;
        i--;
    }
    // 下面
    i = k - 1;
    Node<E> d = head;
    while (i > 0) {
        Node<E> down = new Node();
        d.down = down;
        down.up = d;
        d = down;
        i--;
    }

    // n-1矩阵  subHead n-1矩阵头节点
    Node<E> subHead = build(k - 1, n);

    // 先连接顶部
    Node<E> h = head.right;
    Node<E> subH = subHead;
    while (null != h) {
        h.down = subH;
        subH.up = h;

        h = h.right;
        subH = subH.right;
    }
    // 再连接左侧
    Node<E> down = head.down;
    Node<E> subDown = subHead;
    while (null != down) {
        down.right = subDown;
        subDown.left = down;

        down = down.down;
        subDown = subDown.down;
    }
    return head;
}

 输出矩阵中任意两点之间所有路径

思路： 深度优先搜索(DFS) + 回溯

  1. 如果起始节点相等，直接输出，结束
  2. 起两个栈， 一个主栈，一个副栈
    1. 主栈：存放线路上的节点，用于符合条件时直接输出
    2. 副栈：存放主栈节点的邻接节点集合，需考虑边界与重复遍历问题
  3. 起始节点入主栈，起始节点的邻接节点入副站
  4. 副栈弹出节点集合
    1. 弹出集合中第一个节点node(集合长度-1)
    2. 集合重新入副栈
  5. 如果node=null, 主栈、副栈执行pop()操作，表示需要回溯到上一步(可以理解为，当前无路可走，需要从上一个节点试图走其他方向), 跳转并重复第4步
  6. 如果node!=null, 将node节点压入主栈
  7. 此时如果node==终止节点，则输出主站所有节点，弹出主栈节点(此时==终止节点)，跳转并重复第4步
  8. 将node邻接节点压入副栈

如下图5 * 5矩阵， 起始节点7 ，终止节点19

第一次                                      第二次                                    第三次

第四次                                      第五次                                    第六次

 第**次

  • 此时主栈栈顶元素为19，等于终止节点，则输出主占所有节点值
  • 弹出主栈栈顶节点19，从新取副栈栈顶节点
  • 当前主栈栈顶为18，试图从18开始再向其他方向寻找
  • 18邻接节点取出13，压住主栈

这样，不断压入弹出最终可遍历出所有路线

核心代码

public void search(Node<E> startNode, Node<E> endNode) {

    if (startNode == endNode) {
        System.out.println(startNode.v + " ");
        return;
    }

    // 主栈
    Stack<Node<E>> stack = new Stack<>();
    // 副栈
    Stack<Queue<Node<E>>> adjoinStack = new Stack<>();

    // 将开始节点入主栈
    stack.push(startNode);
    // 将起始节点邻接节点集合如副栈
    this.pushAdjoinStack(stack, startNode, adjoinStack);

    while (!stack.empty()) {
        Queue<Node<E>> queue = adjoinStack.pop();
        Node<E> node = queue.poll();

        adjoinStack.push(queue);
        // 如果到无路可走
        if (null == node) {
            adjoinStack.pop();
            stack.pop();
            continue;
        }

        stack.push(node);

        // 找到一个路径
        if (node == endNode) {
            this.printResult(stack);
            // 弹出主栈栈顶元素
            stack.pop();
            continue;
        }

        pushAdjoinStack(stack, node, adjoinStack);

    }
}

/**
 * 将node节点的邻接几点入副站
 * 1. 边界问题
 * 2. 避免重复入副站
 *
 * @param stack
 * @param node
 * @param adjoinStack
 */
public void pushAdjoinStack(Stack<Node<E>> stack, Node<E> node, Stack<Queue<Node<E>>> adjoinStack) {
    Queue<Node<E>> nodeList = new LinkedList<>();
    if (node.up != null && !stack.contains(node.up)) {
        nodeList.offer(node.up);
    }
    if (node.down != null && !stack.contains(node.down)) {
        nodeList.offer(node.down);
    }
    if (node.left != null && !stack.contains(node.left)) {
        nodeList.offer(node.left);
    }
    if (node.right != null && !stack.contains(node.right)) {
        nodeList.offer(node.right);
    }
    adjoinStack.push(nodeList);
}

完整代码：

/**
 * 节点类
 *
 * @author ywl
 * @version 1.0
 * @date 2024/8/21 20:01
 */

public class Node<E> {
    E v;
    Node<E> up;
    Node<E> down;
    Node<E> left;
    Node<E> right;
    
    // 省略 getter setter
}

import java.util.*;

/**
 * 题目1：给你一个正整数n， 构造一个n*n的四项链表矩阵。
 * 题目2：基于题目1， 在n*n链表矩阵中，输出矩阵中任意两点之间所有路径。
 *
 * @author ywl
 * @version 1.0
 * @date 2024/8/21 20:01
 */
public class StLink<E> {

    public Node<E> build(int k, int n) {
        if (k <= 0) {
            return null;
        }
        Node<E> head = new Node();
        // 右侧
        Node<E> r = head;
        int i = k - 1;
        while (i > 0) {
            Node<E> right = new Node();
            r.right = right;
            right.left = r;
            r = right;
            i--;
        }
        // 下面
        i = k - 1;
        Node<E> d = head;
        while (i > 0) {
            Node<E> down = new Node();
            d.down = down;
            down.up = d;
            d = down;
            i--;
        }

        // n-1矩阵  subHead n-1矩阵头节点
        Node<E> subHead = build(k - 1, n);

        // 先连接顶部
        Node<E> h = head.right;
        Node<E> subH = subHead;
        while (null != h) {
            h.down = subH;
            subH.up = h;

            h = h.right;
            subH = subH.right;
        }
        // 再连接左侧
        Node<E> down = head.down;
        Node<E> subDown = subHead;
        while (null != down) {
            down.right = subDown;
            subDown.left = down;

            down = down.down;
            subDown = subDown.down;
        }
        return head;
    }

    public static void main(String[] args) {
        int n = 4;
        StLink<Integer> sl = new StLink<>();
        Node<Integer> head = sl.build(n, n);

        // 循环赋值
        Node<Integer> down = head;
        int c = 1;
        while (null != down) {
            Node<Integer> right = down;
            while (null != right) {
                right.setV(c++);
                right = right.right;
            }
            down = down.down;
        }

        /**
         * 1  2  3  4
         * 5  6  7  8
         * 9  10 11 12
         * 13 14 15 16
         */
        sl.search(head.right, head.right.right.down.down);
    }

    public void search(Node<E> startNode, Node<E> endNode) {

        if (startNode == endNode) {
            System.out.println(startNode.v + " ");
            return;
        }

        // 主栈
        Stack<Node<E>> stack = new Stack<>();
        // 副栈
        Stack<Queue<Node<E>>> adjoinStack = new Stack<>();

        // 将开始节点入主栈
        stack.push(startNode);
        // 将起始节点邻接节点集合如副栈
        this.pushAdjoinStack(stack, startNode, adjoinStack);

        int maxLen = Integer.MAX_VALUE;
        List<List<E>> result = new ArrayList<>();
        while (!stack.empty()) {
            Queue<Node<E>> queue = adjoinStack.pop();
            Node<E> node = queue.poll();
            adjoinStack.push(queue);

            // 如果无路可走
            if (null == node) {
                adjoinStack.pop();
                stack.pop();
                continue;
            }

            stack.push(node);

            // 找到一个路径
            if (node == endNode) {
                List<E> es = this.printResult(stack);
                if(es.size() == maxLen) {
                    result.add(es);
                } else if(es.size() < maxLen) {
                    maxLen = es.size();
                    result = new ArrayList<>();
                    result.add(es);
                }
                // 弹出主栈栈顶元素
                stack.pop();
                continue;
            }

            pushAdjoinStack(stack, node, adjoinStack);

        }

        System.out.println("最小路径:");
        for(List<E> r : result) {
            for(int i = 0; i < r.size(); i++) {
                System.out.print(r.get(i)+" ");
            }
            System.out.println();
        }
    }

    /**
     * 将node节点的邻接几点入副站
     * 1. 边界问题
     * 2. 避免重复入副站
     *
     * @param stack
     * @param node
     * @param adjoinStack
     */
    public void pushAdjoinStack(Stack<Node<E>> stack, Node<E> node, Stack<Queue<Node<E>>> adjoinStack) {
        Queue<Node<E>> nodeList = new LinkedList<>();
        if (node.up != null && !stack.contains(node.up)) {
            nodeList.offer(node.up);
        }
        if (node.down != null && !stack.contains(node.down)) {
            nodeList.offer(node.down);
        }
        if (node.left != null && !stack.contains(node.left)) {
            nodeList.offer(node.left);
        }
        if (node.right != null && !stack.contains(node.right)) {
            nodeList.offer(node.right);
        }
        adjoinStack.push(nodeList);
    }

    private List<E> printResult(Stack<Node<E>> stack) {
        List<E> r = new ArrayList<>();
        Iterator<Node<E>> iterator = stack.iterator();
        while (iterator.hasNext()) {
            Node<E> next = iterator.next();
            r.add(next.v);
            System.out.print(next.v + " ");
        }
        System.out.println();
        return r;
    }

}

 

●杨毅
关注
  • 10
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言邻接表实现图的任意两点间所有路径
luminais的博客
06-06 5921
#include &amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;string.h&amp;gt; #define DEBUG 1 #if DEBUG #define PRINTF printf #else #define PRINTF #endif //最大节点个数 #define MAX_VEX (256) //标记节点是否被访问过(被加...
matlab两点之间的所有路径,引用 在图中搜索两点间的所有路径matlab编程
weixin_39952190的博客
03-17 2596
引用 在图中搜索两点间的所有路径matlab编程2018-09-18function possiablePaths = findPath(Graph, partialPath, destination, partialWeight)% findPath按深度优先搜索所有可能的从partialPath出发到destination的路径，这些路径中不包含环路% Graph: 路网图，非无穷或0表示两节...
matlab两点之间的所有路径,在图中搜索两点间的所有路径matlab编程
weixin_30844603的博客
03-17 1862
小楼的在图中搜索两点间的所有路径matlab编程在图中搜索两点间所有路径的M文件function possiablePaths = findPath(Graph, partialPath, destination, partialWeight)% findPath按深度优先搜索所有可能的从partialPath出发到destination的路径，这些路径中不包含环路% Graph: 路网图，非无穷...
遍历寻找给定两点之间的所有路径
热门推荐
tan_chi_she的博客
04-09 3万+
直接入题，参加2017年华为竞赛的时候，需要输出路径，当时设了源点和汇点，是单源单汇的寻路径，那么问题就归为寻找给定两点之间的所有路径问题 我们的老师一直教我们这些菜鸟们说，写程序一定要先在纸上写好考虑清楚，这次我觉得这个应该挺简单的，就没写，没想到出现了错误，难调，搞了好久，死循环。然后自己乖乖的关掉vs，乖乖写思路。 首先，确认目的，也就是输入，也就是我们题目的问题：寻找给定两点之间的所有路径
求任意大小矩阵两点之间的最短路径（回溯）
机智的程序员小熊
04-09 6649
任意给定两个正半轴坐标点，求最短路径。 给定起点和终点，求最短路径，一共有八个方向
使用邻接矩阵存储结构，求无向图中任意两点间所有的路径和路径条数
m0_61790474的博客
11-25 1210
#include <stdio.h> #include <iostream> #include <vector> using namespace std; #define Infinity 32766 #define MaxVertexNum 50 typedef struct AMGraph { char vex[MaxVertexNum]; int arc[MaxVertexNum][MaxVertexNum]; int vexnum, arcnum;
利用深度优先遍历求解用邻接矩阵表示的图中任意两个节点的所有路径
MeteorChenBo的博客
06-27 6266
最近科研中需要用到求解图中任意两个姐节点间的所有路径，用到的是图的深度优先遍历及递归的使用，记录在此。 一、图的表示方式——邻接矩阵 我们知道图有两种表示方式，一种是邻接矩阵，一种是邻接表。我使用的是较为容易理解的邻接矩阵，且图为无向无权图，有向有权图的思想和无向无权图类似，在此不赘述。 用邻接矩阵表示无向无权图，即用一个“顶点数×顶点数”的方阵表示节点之间的连接关系，如果两个节点之...
BFS 寻找矩阵中两点之间的最短距离
liuhehe123的博客
09-26 1929
找指定两坐标间的最短距离 这一类 找两点间最短距离的问题一般是使用BFS来解决。 题目描述 给定一个矩阵，x 为坐标起点，即可以用作出发的地方，T 为终点， 即要到达的地方，那么请给出 从 X 出发能到达 T 的最短的路径长度， 以及起点 X 的坐标。 输入：矩阵地图 5 6 X00100 00000X 01T000 0X1010 00000X 输出：一行是最短的路径距离，接着一行是起始点 X 的坐标。 4 0 0 1 5 思路 考虑 BFS 再说一次，广度优先搜索可回答两类问题。  第一类问题：从
在有向图中遍历输出两点之间的所有路径
Nash_SP的博客
09-11 3608
import java.util.*; /* * 在有向图中遍历两点之间的所有路径，节点从0开始记 */ public class Main { static Scanner sc = new Scanner(System.in); static int n,m;//顶点数，边数 static int start,end;//源点，终点 static List<Integer&...
以邻接矩阵求解指定两点长度小于等于N的路径数
weixin_43883746的博客
02-07 1736
用图的邻接矩阵表示法求长度小于等于n的路径总数 设A为图G的邻接矩阵表示。由图论中的知识可以知道AnA^nAn[i][j]表示顶点i到顶点j长度为n的路径数，但如果我们想求i->j的长度小于等于n的路径数该怎么办？ 朴素的做法是求∑k=1nAk[i][j]\displaystyle\sum_{k=1}^{n} A^k[i][j]k=1∑n​Ak[i][j]，这样做的话即使我们多次使用矩阵快速...
图中任意两点间所有路径高效算法
07-28
算法中将一条线视为一个结点，采用广度优先搜索，利用树结构存储搜索结果，算法效率高，在武汉地铁11条线路190余个站点的线网图中测试，任意两点间的所有路径平均耗时0.2秒。只要对算法中的费用矩阵做调整，即可适用...
遍历图中两点之间所有路径的算法
10-17
在计算机科学领域，遍历图中两点之间所有路径的算法是一项重要的任务，特别是在网络分析、图形理论和数据结构的研究中。这个算法可以帮助我们理解网络结构，发现潜在的连接模式，或者在某些应用中，如路由规划、社交...
改算法可以求任意两点之间的最短距离，只要修改里面的邻接矩阵即可.zip
03-10
在给定的压缩包文件“改算法可以求任意两点之间的最短距离，只要修改里面的邻接矩阵即可.zip”中，我们可以推测其核心内容是关于如何通过修改邻接矩阵来实现这一目标的C#代码实现。邻接矩阵是图论中表示图中节点之间...
floyd_floyd最短路径算法_最短路径矩阵_最短路径_只需要改邻接矩阵_
10-03
1. 初始化：首先，我们构建一个邻接矩阵，其中的元素表示图中任意两个节点之间的距离。对于直接相连的节点，距离是边的权重；如果不相连，可以设置为无穷大（表示无法到达）或某个大的正数。 2. 动态规划迭代：算法...
力扣1074.元素和为目标值的子矩阵数量
Pisasama的博客
08-27 83
【代码】力扣1074.元素和为目标值的子矩阵数量。
Numpy 数组及矩阵创建详解
bbaaa123的博客
08-27 844
numpy 数组及矩阵创建详解
matlab 计算矩阵元素的标准差
点云侠的博客
08-24 192
使用matlab计算矩阵中所有元素的标准差。
分块矩阵的转置
最新发布
weixin_40756114的博客
08-27 59
首先证明1）我们先定义两个函数L和H，L用于获取矩阵分块包含的列数，H用于获取矩阵分块包含的行数，令H(接下来证明2）要证明。和后面的分块矩阵中的。的矩阵 2）任意的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值