前言

兄弟們都會有offer的，不要慌，奧力給

一、D星群島（全A，A了0.82的人考慮一下：四個島，現在有兩條橋1-2 3-4）

時間限制： 3000MS
記憶體限制： 589824KB

題目描述：
D星群島由n個小島組成，為了加強小島居民之間的交流，頭目決定啟動一個造橋工程，將全部n個島連接到一起，

由于受到金融危機的影響，頭目要求造橋的總成本要最少，并且還規定每一座橋的成本都不能超過k萬D星幣，

需要注意的是，由于受到地理環境和氣候影響，有些小島之間沒有辦法直接造橋，

現在給你m條小島之間的造橋成本資料以及k的值，請問這個宏偉的造橋工程是否能夠順利完成？

注意：可能邊不夠，也可能費用超支，

輸入描述
多組輸入，第1行輸入一個正整數T表示輸入資料的組數，
對于每一組輸入資料：輸入m+1行，
第1行包含三個正整數，分別表示n、m和k，n≤100，m≤1000，k≤10000，三個數字之間用空格隔開，
接下來m行表示m條小島之間的造橋成本資料，每一行包含三個正整數，分別表示兩個小島的編號（從1開始）和這兩個小島之間的造橋成本（單位：萬），

輸出描述
針對每一組輸入資料，如果能夠完成造橋工程輸出“Yes”，否則輸出“No”，

樣例輸入
2
3 3 400
1 2 200
1 3 300
2 3 500
3 3 400
1 2 500
1 3 600
2 3 700

樣例輸出
Yes
No

代碼：

package didi;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;

/**
 * Created by IntelliJ IDEA.
 *
 * @Author: 
 * @Email: 
 * @Date: 2020/9/13
 * @Time: 19:43
 * @Version: 1.0
 * @Description: Description
 */
public class First3 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        for (int l = 0; l < T; l++) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int k = scanner.nextInt();
            ArrayList<Integer[]> bridges = new ArrayList<>();
            for (int i = 0; i < m; i++) {
                Integer[] bridge = new Integer[2];
                for (int j = 0; j < bridge.length; j++) {
                    bridge[j] = scanner.nextInt();
                }
                if (scanner.nextInt() <= k) {
                    bridges.add(bridge);
                }
            }
            /*if (bridges.size() < n - 1) {//三個島最少也得有兩座橋
                System.out.println("No");
            } else {
                System.out.println("Yes"); //透風小技巧 只寫這部分，不寫下面的能A36%
            }*/
            HashSet<Integer> connections = new HashSet<Integer>();
            if (!bridges.isEmpty()) {
                connections.add(bridges.get(bridges.size() - 1)[0]);
                connections.add(bridges.get(bridges.size() - 1)[1]);
                bridges.remove(bridges.size() - 1);
            }
            while (true) {
                boolean end = true;
                for (int i = bridges.size() - 1; i > -1; i--) {
                    if (connections.contains(bridges.get(i)[0])
                            || connections.contains(bridges.get(i)[1])) {
                        connections.add(bridges.get(i)[0]);
                        connections.add(bridges.get(i)[1]);
                        bridges.remove(i);
                        end = false;
                    }
                }
                if (end) {
                    break;
                }
            }
            if (connections.size() == n) {
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }
        scanner.close();
    }
}

二、畢業旅行（全A）

時間限制： 3000MS
記憶體限制： 589824KB

題目描述：
小滴正在籌劃他的畢業旅行，他打算去找他的外國網友們，首先第一站是法國巴黎，但是去巴黎的路線有很多，交通工具也有很多可供選擇，

現在有一個結點數為n，邊的條數為m的無向圖表示小滴到巴黎的所有路線，其中小滴的家為結點s，巴黎為結點e，小滴出發時間為start，請問小滴最早什么時候能到達巴黎？

輸入描述
單組輸入，數字間有空格隔開，

第一行兩個整數：結點數n，邊數m（n<=1000,m<=10000），

第二行到第m+1行每行各有三個整數：結點u，結點v，需要的時間time（1<=u,v<=n，time<50，time以小時為單位），

最后一行為家的位置：s，巴黎的位置：e，出發時間start（1<=s,e<=n，出發時間格式為month.day/hour，小時為24小時制，出發年份默認為2020年，且一定會在2020年到達，資料保證有解，）

輸出描述
最早能到達巴黎的時間e time（格式與出發時間格式相同），

樣例輸入
4 4
1 2 5
1 3 6
2 4 8
3 4 6
1 4 7.9/8

樣例輸出
7.9/20

提示
輸入樣例2
4 4
1 2 25
1 3 18
2 4 28
3 4 22
1 4 7.9/8

輸出樣例2
7.11/0

代碼：

package didi;
import java.util.*;

/**
 * Created by IntelliJ IDEA.
 *
 * @Author: 張志浩 Zhang Zhihao
 * @Email: 3382885270@qq.com
 * @Date: 2020/9/13
 * @Time: 20:13
 * @Version: 1.0
 * @Description: Description
 */


public class Second2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            List<int[]>[] ways = new List[n + 1];
            for (int i = 0; i < n + 1; i++) {
                ways[i] = new ArrayList<>();
            }
            for (int i = 0; i < m; i++) {
                int l = sc.nextInt();
                int r = sc.nextInt();
                int cost = sc.nextInt();
                int[] lr = {r, cost};
                ways[l].add(lr);
                int[] rl = {l, cost};
                ways[r].add(rl);
            }
            int start = sc.nextInt();
            int tar = sc.nextInt();
            String time = sc.next();

            int[] arrived = new int[n + 1];
            Arrays.fill(arrived, Integer.MAX_VALUE);
            Deque<int[]> list = new LinkedList<>();
            list.add(new int[]{start, 0});
            while (!list.isEmpty()) {
                int[] cur = list.poll();
                int pos = cur[0];
                int cost = cur[1];
                if (cost < arrived[pos]) {
                    arrived[pos] = cost;
                    for (int[] arr : ways[pos]) {
                        if (arr[1] + cost < arrived[arr[0]]) {
                            list.add(new int[]{arr[0], arr[1] + cost});
                        }
                    }
                }
            }
            int res = arrived[tar];
            String out = help(res, time);
            System.out.println(out);
        }
    }

    static int[] months = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

    public static String help(int res, String time) {
        String[] temp = time.split("\\.");
        int month = Integer.parseInt(temp[0]);
        temp = temp[1].split("/");
        int day = Integer.parseInt(temp[0]);
        int hour = Integer.parseInt(temp[1]);

        hour += res;
        if (hour >= 24) {
            day += hour / 24;
            hour = hour % 24;
        }
        while (day > months[month]) {
            day -= months[month];
            month++;
        }
        StringBuilder arrive = new StringBuilder();
        arrive.append(month).append(".")
                .append(day).append("/").append(hour);

        return arrive.toString();
    }
}