休息旅途

题目：

1. 休息旅途

[问题描述]
又是一年平安夜，MZ正在家中计划如何轻松愉快地度过，猛然想起今天好像是MM的生日耶……
于是MZ立刻从家里出发，直奔MM家中。但MZ体力很不好，每跑一段路就要休息一会儿。已知MZ家编号为1，MM家编号为N，中间标号2~N-1均为休息站，同时知道每个站点之间的距离。你能为MZ设计一条路线，使得该路线上MZ连续奔跑的最大距离最小吗？

[输入]
第一行包含两个正整数N，M，分别表示节点数和边数
接下来M行每行三个数 u，v，dist，表示节点u与节点v中间存在距离为dist的一条无向边。

[输出]
一个整数min_edge，表示MZ连续奔跑最大距离的最小值。如果不能到达，输出-1

[样例输入]
3 3
1 2 2
2 3 2
1 3 3

[样例输出]
2

[样例解释]
1,3之间有两条路，分别为1->2->3,1->3
前者连续奔跑最大距离为2，后者为3.

[数据范围]
对于100%的数据，N,M<=10000

题解：

首先虽然数据是100000的规模，但似乎也不是很大啦
于是我们可以这样乱搞，我们每次二分枚举一个最大权值w，把大过w的边全部删去，再看看1和N是否连通，这个可以使用广搜实现，如果1和N连通，说明w较大，反之说明w较小，二分逼近最后就是答案
时间复杂度O(m log ans)

package relax;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Vector;
class Node{

        int v,dist;
        public Node(int v, int dist) {
            this.v = v;
            this.dist = dist;
        }

}
public class relax {
    static int MAXN=100010;
    static Vector<Node>[] G = new Vector[MAXN];
    static int inf=0x7fffffff;

    static int m,N;
    static int[] vis=new int[MAXN];


    static boolean dfs(int ind,int limit){
        vis[ind]=1;
        if(ind==N){
            return true;
        }
        for (int i = 0; i < G[ind].size(); i++) {
            Node node =((Node) G[ind].get(i));
            int to = node.v;
            if (vis[to] == 0 &&node.dist<=limit) {
                vis[to] = 1;

                if( dfs(to,limit)){
                    return true;
                };
              /*
               * 错误写法：return dfs();子节点搜索不到N返回false,会导致整体返回false;
               * 错误写法：dfs();导致永远返回false;
               */
            }
        }
        return false;
    }
    static boolean isOk(int limit){
        boolean ans=true;
        Arrays.fill(vis, 0);
        ans=dfs(1,limit);
        return ans;
    }

    static boolean bfs(int limit){
        Queue q=new LinkedList();
        Arrays.fill(vis, 0);
        vis[1]=1;
        q.add(1);
        while(!q.isEmpty()){
            int ind=(int)q.poll();

            if(ind==N){
                return true;
            }
            for (int i = 0; i < G[ind].size(); i++) {
                Node node =((Node) G[ind].get(i));
                int to = node.v;
                if (vis[to] == 0 &&node.dist<=limit) {
                    vis[to] = 1;
                    q.add(to);
                }
        }


     }
        return false;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        m = sc.nextInt();
        int a[]=new int[m];
        // System.out.println(n);

        for (int i = 1; i <= N+1; i++) {
            G[i] = new Vector<Node>();
        }
        for (int i = 0; i <m; i++) {
            int from =sc.nextInt(),to=sc.nextInt(),dist=sc.nextInt();
            G[from].add(new Node(to,dist));
            G[to].add(new Node(from,dist));
            a[i]=dist;
        }

        if(!bfs(inf)){
            System.out.println("-1");
        }else{
            Arrays.sort(a);
            int l=0,r=m-1;

            while(l<=r){
                int mid=(l+r)/2;
                if(bfs(a[mid])) r=mid-1;
                else l=mid+1;
            }
            System.out.println(a[l]);
        }


    }
}