致命错误（构造器）JAVA

import java.util.*;
public class Main{
public static void main(String[] args){
  Scanner sc=new Scanner(System.in);
  mycart s1=new mycart();
  s1.N=sc.nextInt();
  int m=sc.nextInt();
  String s="";
  String a[]=null;
  String s2=sc.nextLine();
  Nodepiont t=null;
  for(int i=0;i<m;i++)
  {
	 s=sc.nextLine();
	 a=s.split("\\s+");
     t=new Nodepiont(Integer.parseInt(a[1]),Integer.parseInt(a[2]));
     t.next=s1.a[Integer.parseInt(a[0])].nextone;
     s1.a[Integer.parseInt(a[0])].nextone=t;
  }
  s1.visit[1]=1;
  s1.dfs(s1, 1, 0);
  if(s1.flag==0)
  System.out.println("-1");
  else
  System.out.println(s1.Min);
}
}
class Nodehead
{
 int data;
 Nodepiont nextone;
 Nodehead()
 {
  nextone=null;
 }
}
class Nodepiont
{
 int number;
 Nodepiont next;
 int pace;
 Nodepiont ()
 {
	 next=null;
 }
 Nodepiont(int x,int y)
 {
  number=x;
  pace=y;
  next=null;
 }
}
class mycart
{
 Nodehead a[];
 int Min=0x3f3f3f3f;
 int N;
 int flag=0;
 int visit[];
 mycart(){
 a=new Nodehead[N+10];
 for(int i=0;i<N+10;i++)
 a[i]=new Nodehead();
 visit =new int[N+10];
 }
 public void dfs(mycart s1,int v,int k)
 {
  if(v==N)
  {
	Min=Math.min(Min, k);
	flag++;
	return ;
  }
  Nodepiont t=null;
  t=s1.a[v].nextone;
  Queue <Nodepiont> qu =new LinkedList<Nodepiont>();
  while(t!=null)
  {
	  qu.offer(t);
	  t=t.next;
  }
  while(!qu.isEmpty())
  {
	  t=qu.poll();
	  if(s1.visit[t.number]==0)
	  {
	  s1.visit[t.number]=1;
	  dfs(s1,t.number,t.pace+k);
	  s1.visit[t.number]=0;
	  }
  }
 }
}

 解析：如上图所示，我先调用了类mycart再对内部N进行赋值，企图对a[]分配对应内存。

不过已经太晚了，在我调用mycart类时a已经被分配10空间了，太晚了。这是一个致命错误。如下是修改后的代码。

import java.util.*;
public class Main{
public static void main(String[] args){
  Scanner sc=new Scanner(System.in);
  int n=sc.nextInt();
  mycart s1=new mycart(n);
  int m=sc.nextInt();
  String s="";
  String a[]=null;
  String s2=sc.nextLine();
  Nodepiont t=null;
  for(int i=0;i<m;i++)
  {
	 s=sc.nextLine();
	 a=s.split("\\s+");
     t=new Nodepiont(Integer.parseInt(a[1]),Integer.parseInt(a[2]));
     t.next=s1.a[Integer.parseInt(a[0])].nextone;
     s1.a[Integer.parseInt(a[0])].nextone=t;
  }
  s1.visit[1]=1;
  s1.dfs(s1, 1, 0);
  if(s1.flag==0)
  System.out.println("-1");
  else
  System.out.println(s1.Min);
}
}
class Nodehead
{
 int data;
 Nodepiont nextone;
 Nodehead()
 {
  nextone=null;
 }
}
class Nodepiont
{
 int number;
 Nodepiont next;
 int pace;
 Nodepiont ()
 {
	 next=null;
 }
 Nodepiont(int x,int y)
 {
  number=x;
  pace=y;
  next=null;
 }
}
class mycart
{
 Nodehead a[];
 int Min=0x3f3f3f3f;
 int N;
 int flag=0;
 int visit[];
 mycart(int n){
 a=new Nodehead[n+10];
 for(int i=0;i<n+10;i++)
 a[i]=new Nodehead();
 visit =new int[n+10];
 N=n;
 }
 public void dfs(mycart s1,int v,int k)
 {
  if(v==N)
  {
	Min=Math.min(Min, k);
	flag++;
	return ;
  }
  Nodepiont t=null;
  t=s1.a[v].nextone;
  Queue <Nodepiont> qu =new LinkedList<Nodepiont>();
  while(t!=null)
  {
	  qu.offer(t);
	  t=t.next;
  }
  while(!qu.isEmpty())
  {
	  t=qu.poll();
	 // System.out.println(t.number);
	  if(s1.visit[t.number]==0)
	  {
	  s1.visit[t.number]=1;
	  dfs(s1,t.number,t.pace+k);
	  s1.visit[t.number]=0;
	  }
  }
 }
}

​​​​以下是正确代码在具体题目中的效果：

Beabled的奇妙梦中旅程 PTA

Beabled（简称小B）喜欢睡觉，有时候一睡就是一整天，因此小B因睡觉耽误了好多事而受责怪。
有一次，小B下午有一个重要的会议，但是小B现在很困，所以小B决定午睡一会，但是很不巧，做梦的时候小B发现自己被困在梦里出不去了，小B非常慌忙，但是却无能为力。
这时有一个士兵过来告诉小B，说他有办法让小B逃脱梦境，士兵说：附近有n个城堡，小B所处的位置就是1号古堡，每个古堡之间原本有互通的道路，但是因为政权问题，部分道路被阻断，现只存在部分连通的道路，而且每条连通的道路长度也不尽相同。在第n个城堡里，有女巫可以制造摆脱梦境的解药，你去要找到这个女巫，才有机会摆脱梦境。

小B听完后很感动，正准备动身前往时，士兵把小B拦下，说：
别着急，我还没告诉你古堡的分布呢，你现在去怎么能找到？我将会告诉你有m条连通两个古堡的道路，道路只能单向通过，以及每条道路的路径长度l，剩下的就交给你了。

小B深知是场梦，听完还是很感动！在筹备好行动路线后就以最短的路径前往第n个古堡了。最终小B成功逃脱了梦境，赶上了重要的会议。那么聪明的你一定也能算出小B前往第n个古堡最短的路径是多少吧？

输入格式:

第一行包含整数n和m。

接下来m行每行包含三个整数a，b，c，表示存在一条从点a到b的有向边，边长为c。

1 <= a, b <= n， 0 < c <= 10000。

输出格式:

输出一个整数，表示小B从1号古堡到n号古堡的最短距离。
若路径不存在，则输出-1。

输入样例:

在这里给出一组输入。例如：

3 3
1 2 2
2 3 1
1 3 4

输出样例:

在这里给出相应的输出。例如：

3

数据范围与提示:

对于百分之20的数据n,m<=50,

对于百分之40的数据,n<=500,m<=1000,

对于百分之70的数据,n<=5000，m<=10000，

对于百分之100的数据,n,m<=150000。

代码长度限制
16 KB
Java (javac)
时间限制
1000 ms
内存限制
128 MB
Python (python3)
时间限制
1000 ms
内存限制
128 MB
其他编译器
时间限制
400 ms
内存限制
64 MB

测试结果：

 

 这道题的解法我依旧延续了迷宫路径的思维，并在此基础上我用队列代替for循环创新出新的遍历规则，虽然说最后几个超时了，但还是说明我这个创新思维是可行的，同时我也找到致命错误的原因，这给了我很多警醒，我在以后犯这种错误的概率就少了，也是收获良多的。

本题答案在这个大哥写的博客的第9题

bhttp://t.csdn.cn/syhWs