【九度】题目1417：变型金刚

题目1417：变型金刚

题目描述：
      看过变形金刚的人一定记得这样一个场景，机器人在攻击人类的时候，可以上天入地，并且都如履平地。
      聪明的人类很快就想到，可不可以也利用地下的攻势来跟机器人进行周旋。很快，人类就在地下建立了几个基地。现在这些基地之间要进行合作，必须有一些基地之间是有通道的，这样无论是运输补给还是进行交流都会方便很多。在每两个基地之间都建立一个通道，这是一个好的方法，基地之间的交流会变得极其方便。但是，同时要考虑到修地下通道所花的人力、物力、以及时间。现在时间很紧迫，必须选择一些通道来进行修建。根据对地形的分析及研究，人类确定了一些适合修建的备选通道。相信聪明的你很快会想到，这些通道也不用全部都修建，只要修建一些通道，使得任意两个基地之间都互相可达就可以了。通道修好后，还有最后一项工作要做，就是在每条修好的通道之间都铺设一段铁轨，铁轨需要的费用与通道的长度相同。同时，跟现实中的铁路不同，地下的铁路每次只能买一批固定长度的钢轨，每条通道用一条钢轨，如果钢轨的长度大于通道的长度，剩下的丢弃即可。现在人类将确定的备选通道的数目，每条通道连接的两个基地名称，以及这条通道的长度告诉你。请问购买的这一批钢轨的长度最短要多长才能满足要求？
 
 

  
  
   
   输入：
      输入的第一行包括基地的个数n(1<=n<=100)，以及备选通道的个数m(1<=m<=10000)。
      接下来的m行，每行代表一个备选通道，其中包括两个字符串base1及base2，代表两个基地的名称(字符串的长度1<=len<=100)，以及一个整数w(1<=w<=10000000)，代表这两个基地之间的距离。
  
  
 
 
 
 

  
  
   
   输出：
  
  
  
  
   
         输出购买的这一批钢轨的长度最短需要的长度。如果题目中给出的备选通道，不论你怎么选择，都不能使任意两个基地之间可以互相可达，那么请输出 “My God” 即可。
  
  
 
 
 
 

  
  
   
   样例输入：
5 8
a b 2
a c 3
b d 4
a d 2
b c 1
d e 3
a e 2
c e 5
5 5
a c 3
a d 2
d e 3
a e 2
c e 5

  
  
 
 
 
 

  
  
   
   样例输出：
2
My God

  
  
 
 
 
 

  
  
   
   提示：
    1.由于修建方案的不同，数据中给出的两个基地之间的距离可能有多个，取最短的那个即可。
  
  
 
 

【解题思路】
其实这个题目和题目1545：奇怪的连通图基本思路一样。
仍然是使用并查集。
但是这次要求是所有的通道都连通。
所以break的条件有点不太一样。
1、输入节点，可以用对象或者struct。
2、根据距离从小到大排序。
3、合并节点。发现当前道路条数已经比节点个数小1的时候break。
4、输出结果。
当然也可以用prim算法去做。
Java和C++的prim算法都超时， 虽然10个案例都AC了。
换用并查集以后，都AC了。我会给出四个案例的代码。
Java prim算法 TLE

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
 
public class Main {
    /*
     * 1417
     */
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
               
            int size = 102;
            int path[][] = new int[size][size];
               
            for (int i = 1; i < size; i++) {
                for (int j = 1; j < size; j++) {
                    path[i][j] = Integer.MAX_VALUE;
                }
            }
            Map<String, Integer> baseMap = new HashMap<String, Integer>();
            int currNum = 0;
            for (int i = 0; i < m; i++) {
                String a = scanner.next();
                String b = scanner.next();
                int d = scanner.nextInt();
                int anum = 0;
                int bnum = 0;
                if (!baseMap.containsKey(a)) {
                    currNum++;
                    anum = currNum;
                    baseMap.put(a, anum);
                }else {
                    anum = baseMap.get(a);
                }
                   
                if (!baseMap.containsKey(b)) {
                    currNum++;
                    bnum = currNum;
                    baseMap.put(b, bnum);
                }else {
                    bnum = baseMap.get(b);
                }
                   
                if (path[anum][bnum] > d ) {
                    path[anum][bnum] = d;
                    path[bnum][anum] = d;
                }
            }
              
            if (currNum < n) {
                System.out.println("My God");
                continue;
            }
              
            int minLen[] = new int[size];
            int visit[] = new int[size];
            for (int i = 1; i < size; i++) {
                minLen[i] = path[1][i];
            }
            prime(path , minLen , visit ,n);
        }
    }
   
    private static void prime(int[][] path, int[] minLen, int[] visit, int n) {
           
        minLen[1] = 0;
        visit[1] = 1;
        int minj = 1;
        int resLen = 0;
        for (int i = 1; i < n; i++) {
            int min = Integer.MAX_VALUE;
            for (int j = 1; j < n+1; j++) {
                if (visit[j] == 0 && minLen[j] < min) {
                    min = minLen[j];
                    minj = j;
                }
            }
            visit[minj] = 1;
               
            if (min > resLen) {
                resLen = min;
            }
               
            for (int j = 1; j < n+1; j++) {
                if (visit[j] == 0 && minLen[j] > path[minj][j]){
                    minLen[j] = path[minj][j];
                }
            }
        }
        int num = 0;
        for (int i = 1; i < n + 1; i++) {
            if (visit[i] == 1) {
                num ++;
            }
        }
        System.out.println(num == n ? resLen : "My God");
    }
}
/**************************************************************
    Problem: 1417
    User: wzqwsrf
    Language: Java
    Result: Time Limit Exceed
****************************************************************/

Java 并查集 TLE

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
 
public class Main {
    /*
     * 1417
     */
    private static int parent[];
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            initParent(n);
            Map<String, Integer> baseMap = new HashMap<String, Integer>();
            int currNum = 0;
            int count = 0;
            int maxLen = 0;
            Node nodes[] = new Node[m];
            for (int i = 0; i < m; i++) {
                String a = scanner.next();
                String b = scanner.next();
                int d = scanner.nextInt();
                int anum = 0;
                int bnum = 0;
                if (!baseMap.containsKey(a)) {
                    currNum++;
                    anum = currNum;
                    baseMap.put(a, anum);
                }else {
                    anum = baseMap.get(a);
                }
                   
                if (!baseMap.containsKey(b)) {
                    currNum++;
                    bnum = currNum;
                    baseMap.put(b, bnum);
                }else {
                    bnum = baseMap.get(b);
                }
                nodes[i] = new Node(anum, bnum, d);
            }
             
            Arrays.sort(nodes);
            boolean flag = false;
            for (int i = 0; i < m; i++) {
                if (findParent(nodes[i].start) != findParent(nodes[i].end)) {
                    count++;
                    unionTwo(nodes[i].start, nodes[i].end);
                    maxLen = nodes[i].value;
                    if(count == n-1){
                        flag = true;
                        break;
                    }
                }
            }
            if (flag || count == n-1) {
                System.out.println(maxLen);
            }else {
                System.out.println("My God");
            }
        }
    }
     
    private static void initParent(int n) {
        parent = new int[n+1];
        for (int i = 1; i < n+1; i++) {
            parent[i] = i;
        }
    }
 
    private static void unionTwo(int f, int t) {
         
        int a = findParent(f );
        int b = findParent(t );
        if (a == b) return; 
        if (a > b) {   
            parent[a] = b;   
         } else {
            parent[b] = a; 
         }
    }
   
    private static int findParent(int f) {
        while (parent[f] != f) {
            f = parent[f];
        }
        return f;
    }
     
    private static class Node implements Comparable<Node>{
        int start;
        int end;
        int value;
        public Node(int start, int end, int value) {
            super();
            this.start = start;
            this.end = end;
            this.value = value;
        }
        public int compareTo(Node o) {
            if (this.value < o.value) {
                return -1;
            }else if (this.value > o.value) {
                return 1;
            }
            return 0;
        }
    }
}
 
/**************************************************************
    Problem: 1417
    User: wzqwsrf
    Language: Java
    Result: Time Limit Exceed
****************************************************************/

C++ prim AC

#include<stdio.h>
#include<algorithm> 
#include <string.h>
using namespace std;
#define INF 1000000000;
const int maxn = 105;
char name[maxn][maxn];
int currNum;
char s[maxn];
int visit[maxn];
int path[maxn][maxn];
int minLen[maxn];
int n;
int maxLen;
int i,j;
 
int getIndex(){
    for(i=1; i<currNum; i++){
        if(strcmp(name[i],s) == 0){
            return i;
        }
    }
    return currNum;
}
 
void initArr(){
    for (i = 1; i < maxn; i++) {
        for (j = 1; j < maxn; j++) {
            path[i][j] = INF;
        }
    }
    memset(minLen,0,sizeof(minLen));
    memset(visit,0,sizeof(visit));
}
 
int prime(){
    minLen[1] = 0;
    visit[1] = 1;
    int minj = 1;
    maxLen = 0;
    for (i = 1; i < n; i++) {
        int min = INF;
        for (j = 1; j < n+1; j++) {
            if (visit[j] == 0 && minLen[j] < min) {
                min = minLen[j];
                minj = j;
            }
        }
        visit[minj] = 1;
        if (min > maxLen) {
            maxLen = min;
        }
  
        for (j = 1; j < n+1; j++) {
            if (visit[j] == 0 && minLen[j] > path[minj][j]){
                minLen[j] = path[minj][j];
            }
        }
     }
 
    int num = 0;
    for (int i = 1; i < n + 1; i++) {
        if (visit[i] == 1) {
            num ++;
        }
    }
    return num;
}
 
int main(){
     
    int m;
    while(scanf("%d%d",&n,&m)!=EOF){
        int i = 0;
        currNum = 1;
        initArr();
        for(i=0; i < m; i++){
            scanf("%s",s);
            int a = getIndex();
            if(currNum == a){
                strcpy(name[currNum++],s);
            }
            scanf("%s",s);
            int b = getIndex();
            if(currNum == b){
                strcpy(name[currNum++],s);
            }
            int d;
            scanf("%d",&d);
            if(path[a][b] > d){
                path[a][b] = d;
                path[b][a] = d;
            }
        }
             
  
        for (i = 1; i < maxn; i++) {
            minLen[i] = path[1][i];
        }
        int tempNum = prime();
        if(tempNum == n){
            printf("%d\n",maxLen);
        }else{
            printf("%s\n","My God");
        }  
    }
    return 0;
}
/**************************************************************
    Problem: 1417
    User: wzqwsrf
    Language: C++
    Result: Accepted
    Time:110 ms
    Memory:1076 kb
****************************************************************/

C++ 并查集 AC

#include<stdio.h>
#include<algorithm> 
#include <string.h>
using namespace std;
const int maxn = 105;
const int maxm = 10005;
char name[maxn][maxn];
int currNum;
int parent[maxn];
char s[maxn];
struct Node{
    int start;
    int end;
    int value;
}nodes[maxm];
   
int getIndex(){
   
    for(int i=1; i < currNum; i++){
        if(strcmp(name[i],s) == 0){
            return i;
        }
    }
    return currNum;
}   
int compare(Node node1 ,Node node2){
    if(node1.value < node2.value){
        return 1;
    }
    return 0;
}
      
int findParent(int f) {
     while (parent[f] != f) {
        f = parent[f];
    }
    return f;
}
   
void unionTwo(int f, int t) {
               
     int a = findParent(f);
     int b = findParent(t);
     if (a == b){
        return;
     }
     if (a > b) {
         parent[a] = b;
     } else {
         parent[b] = a;
     }
}
        
int main(){
      
    int n;
    int m;
    while(scanf("%d%d",&n,&m)!=EOF){
        int i = 0;
        currNum = 1;
        for(i=0; i < m; i++){
            scanf("%s",s);
            int a = getIndex();
            if(currNum == a){
                strcpy(name[currNum++],s);
            }
            scanf("%s",s);
            int b = getIndex();
            if(currNum == b){
                strcpy(name[currNum++],s);
            }
            nodes[i].start = a;
            nodes[i].end = b;
            scanf("%d",&nodes[i].value);
        }
          
        sort(nodes,nodes+m,compare);
   
        for(i = 1; i < maxn ; i++){
            parent[i] = i;
        }
        int maxLen = 0;
        int count = 0;
        bool flag = false;
        for (i = 0; i < m; i++) {
            if (findParent(nodes[i].start) != findParent(nodes[i].end)) {
                count++;
                unionTwo(nodes[i].start, nodes[i].end);
                maxLen = nodes[i].value;
                if(count == n-1){
                    flag = true;
                    break;
                }
            }
        }
        if(flag || count == n-1){
            printf("%d\n",maxLen); 
        }else{
            printf("%s\n","My God");
        }
              
    }
    return 0;
}
/**************************************************************
    Problem: 1417
    User: wzqwsrf
    Language: C++
    Result: Accepted
    Time:100 ms
    Memory:1148 kb
****************************************************************/