Java算法_Map——HDU 2094：产生冠军

Map

Map接口中常用集合

 通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

集合	说明
HashMap<K,V>	存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap<K,V>	HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

Map<K,V>

方法	说明
get	获取指定键(key)所对应的值(value)
put	将指定的键与值对应起来，并添加到集合中， 方法返回值为键所对应的值，使用put方法时，若指定的键(key)在集合中
remove	根据指定的键(key)删除元素，返回被删除元素的值(value)。

 使用put方法时，若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

public class MapDemo {
    public static void main(String[] args) {
        //创建Map对象
        Map<String, String> map = new HashMap<String,String>();       //数据采用的哈希表结构
        //给map中添加元素
        map.put("星期一", "Monday");
        map.put("星期日", "Sunday");
        System.out.println(map); // {星期日=Sunday, 星期一=Monday}
 
        //当给Map中添加元素，会返回key对应的原来的value值，若key没有对应的值，返回null
        System.out.println(map.put("星期一", "Mon")); // Monday
        System.out.println(map); // {星期日=Sunday, 星期一=Mon}
 
        //根据指定的key获取对应的value
        String en = map.get("星期日");
        System.out.println(en); // Sunday
        
        //根据key删除元素,会返回key对应的value值
        String value = map.remove("星期日");
        System.out.println(value); // Sunday
        System.out.println(map); // {星期一=Mon}
    }
}

Map集合遍历

//假设key 为Integer型 value 为String ，具体自行定义
Map<Integer,String> map = new HashMap<Integer,String>();

//放入数据
map.put(1,"a");
map.put(2,"b");
map.put(3,"c");

//根据key获取对应的value
map.get(1); //获取到对应key=1时的value=a

//遍历方法1：keyset遍历
Iterator<String> iter = map.keySet().iterator();
 
while (iter.hasNext()) {
    int key = iter.next();
    String value = map.get(key);
}
//------------------------------------------------
//还有一种写法 用for each
for (String key : map.keySet()) {
    String value = map.get(key);
}

//遍历方法2：Iterator迭代器遍历
Iterator<Entry<String, String>> iter = map.entrySet().iterator();
Entry<String, String> entry;
while (iter.hasNext()) {
    entry = iter.next();
    int key = entry.getKey();
    String value = entry.getValue();
}

HDU 2094：产生冠军

http://acm.hdu.edu.cn/showproblem.php?pid=2094

Problem Description

有一群人，打乒乓球比赛，两两捉对撕杀，每两个人之间最多打一场比赛。
球赛的规则如下：
如果A打败了B，B又打败了C，而A与C之间没有进行过比赛，那么就认定，A一定能打败C。
如果A打败了B，B又打败了C，而且，C又打败了A，那么A、B、C三者都不可能成为冠军。
 根据这个规则，无需循环较量，或许就能确定冠军。你的任务就是面对一群比赛选手，在经过了若干场撕杀之后，确定是否已经实际上产生了冠军。

Input

 输入含有一些选手群，每群选手都以一个整数n(n<1000)开头，后跟n对选手的比赛结果，比赛结果以一对选手名字（中间隔一空格）表示，前者战胜后者。如果n为0，则表示输入结束。

Output

对于每个选手群，若你判断出产生了冠军，则在一行中输出“Yes”，否则在一行中输出“No”。

Sample Input

3
Alice Bob
Smith John
Alice Smith
5
a c
c d
d e
b e
a d

Sample Output

Yes
No

package com.hhhyixin.book.cp03.hdu_2094;

import java.io.*;
import java.util.*;

public class Main {
    int t, n, cet;
    int[] degree = new int[1001];
    HashMap<String, Integer> hm = new HashMap<String, Integer>();

    public static void main(String[] args) {
        new Main().work();//调用开始函数
    }

    void work() {   //开始比试
        Scanner sc = new Scanner(new BufferedInputStream(System.in));
        while (sc.hasNext()) {
            t = sc.nextInt();   //输入要比试的轮数
            if (t == 0) break;  //轮数为0就系统就终止

            init(); //调用init函数，是用来清除map中的数据
            //给每个字符串标号
            for (int i = 0; i < t; i++) {
                String s1 = sc.next();  //  输入获胜的选手的信息
                if (!hm.containsKey(s1)) { //如果map集合中，不包含这个获胜选手的信息，就加到map集合中，如果有该信息，就不用进循环
                    hm.put(s1, n);  //将获胜的选手存入map集合中
                    n++;//n+1
                }
                String s2 = sc.next();//输入失败的选手的信息
                if (!hm.containsKey(s2)) {
                    hm.put(s2, n);  //将失败的选手存入map集合中
                    n++;//n+1
                }
                union(hm.get(s1), hm.get(s2));
            }

            cet = 0;
            for (int i = 0; i < n; i++) {
                if (degree[i] == 0)
                    cet++;  //用cet来存取degree中有几个0
            }

            if (cet == 1)   //当degree中只有一个0，也就是cet=1的时候，说明有冠军产生
                //因为degree中只有一个0的时候，说明只有一个获胜者没有被打败过，他就是冠军
                System.out.println("Yes");
            else
                System.out.println("No");
        }
    }

    void init() {
        n = 0;
        hm.clear();
        Arrays.fill(degree, 0);
    }

    void union(int a, int b) {
        degree[b]++;//a赢了b, a->b, b的入度加1

    }

}