给定起点寻找邻接矩阵中的闭环

招行题目：
有一个矩阵A是
0 1 0 0 0
0 0 1 1 0
1 0 0 0 0
0 0 0 0 1
0 1 1 0 0

A[0][1] == 1，表示节点0会调用节点1
A[4][0] == 0，表示节点4不调用节点0

将矩阵画出之后，可以观察到，若从服务4出发，存在环：
4->1->3->4
4->2->0->1->3->4

请编程满足以下的输入输出要求：
1.程序输入
5
0 1 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 1 0 1 1 0 0
4
说明：第一行矩阵行数，第二行为矩阵值，第三行为起点服务编号

2.程序输出
413
42013
说明：逐行输出环路信息

这道题其实思路很简单，就是去寻找矩阵中的闭环，
但是一直困住我的有3点：
1.输入时，如果已知输入的行数，可先设定读入的行数值，之后用nextLine()进行输入

 Scanner sc = new Scanner(System.in);
 int m = 3;
String[] strArr = new String[m];
for (int i = 0;i < m;i++){
    strArr[i] = sc.nextLine();
}
int point = Integer.parseInt(strArr[0]);
int[][] arr_p = new int[point][point];

String[] arr_one = strArr[1].trim().split(" ");
int a_index = 0;
for (int i = 0;i < point;i++){
     for (int j = 0;j < point;j++){
         arr_p[i][j] = Integer.parseInt(arr_one[a_index]);
         a_index = a_index + 1;
         }
 }

int start_point = Integer.parseInt(strArr[2]);

2.我在进行dfs的时候，如何保存满足条件的路径
解决方法：设定一个全局变量，但是如果在main函数所在的类中设定全局变量，在lianbiao的子函数中无法对全局变量进行改变。所以我重新建立了一个demo类。
注意！想在类中调用全局变量并且进行修改，需要加上static关键字。

3.保存temp_list的状态，需要在每次dfs之前进行值传递，但是如果用ArrayList t_t = temp_list进行的是引用传递，如果需要值传递就需要使用clone()函数，并且如果使用List list = new ArrayList<>();建立list是无法使用clone的，需要使用ArrayList list = new ArrayList<>();来进行建立list。

代码：

package zhaoshang;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class lianbiao {
    public static void main(String[] args) {
        //输入
        Scanner sc = new Scanner(System.in);
//        int points = sc.nextInt();
//        int[][] arr_p = new int[points][points];
        int m = 3;
        String[] strArr = new String[m];
        for (int i = 0;i < m;i++){
            strArr[i] = sc.nextLine();
        }
        int point = Integer.parseInt(strArr[0]);
        int[][] arr_p = new int[point][point];

        String[] arr_one = strArr[1].trim().split(" ");
        int a_index = 0;
        for (int i = 0;i < point;i++){
            for (int j = 0;j < point;j++){
                arr_p[i][j] = Integer.parseInt(arr_one[a_index]);
                a_index = a_index + 1;
            }
        }

        int start_point = Integer.parseInt(strArr[2]);
//        int point = 5;
//        String arr = "0 1 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 1 0 1 1 0 0";
//        String[] arr_one = arr.trim().split(" ");
//        int[][] arr_p = new int[point][point];
//        int a_index = 0;
//        for (int i = 0;i < point;i++){
//            for (int j = 0;j < point;j++){
//                arr_p[i][j] = Integer.parseInt(arr_one[a_index]);
//                a_index = a_index + 1;
//            }
//        }
//        int start_point = 4;

        demo d = new demo();
        ArrayList<ArrayList<Integer>> li = d.find(arr_p, start_point);
        for (ArrayList<Integer> i:li){
            System.out.println(i);
        }

    }




}
class demo{
    //基于stat_point行去查找闭环
    static ArrayList<ArrayList<Integer>> results = new ArrayList<>();
    public  ArrayList<ArrayList<Integer>> find(int[][] arr,int start_point){


        for (int i = 0;i < arr[0].length;i++){
            if (arr[start_point][i] == 1){
                ArrayList<Integer> temp_list = new ArrayList<>();
                temp_list.add(start_point);
//                int index_t = arr[start_point][i];
                select(arr,i,start_point,temp_list);
            }
        }
        return results;
    }

    public void select(int[][] arr,int index_t,int start_point,ArrayList<Integer> temp_list){

        if (index_t == start_point){
            results.add(temp_list);
            return;
        }
        if (temp_list.size() > arr[0].length){
            return;
        }
        for (int i = 0;i < arr[0].length;i++){
            if (arr[index_t][i] == 1){

                if (!temp_list.contains(index_t)){
                    ArrayList<Integer> t_t = (ArrayList<Integer>) temp_list.clone();
                    temp_list.add(index_t);
                    select(arr,i,start_point,temp_list);
                    temp_list = t_t;
                }

            }
        }
    }
}