码迷，mamicode.com
首页 > 编程语言 > 详细

ACM等算法比赛中JAVA 常用"STL"总结:TreeMap,Queue,PriorityQueue等

时间：2016-05-27 11:33:56      阅读：368      评论：0      收藏：0      [点我收藏+]

标签：

第一个：显然是I/O的class啦~！

/*IO相关*/
class InputReader
{
	public InputReader() {
		// TODO Auto-generated constructor stub
		tokenizer = new StringTokenizer("");
		reader = new BufferedReader(new InputStreamReader(System.in));
	}
	public String nextTokenizer()	throws IOException
	{
		while (!tokenizer.hasMoreTokens())
		{
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
		
	}
	public int nextInt()	throws IOException
	{
		return Integer.valueOf(nextTokenizer());
	}

	StringTokenizer tokenizer;
	BufferedReader	reader;
}


Map使用：

比赛常用HashMap和TreeMap


先介绍TreeMap:

二叉树Map嘛，自然就是log级各种运算的时间。所以对自定义结构体需要定义比较函数。


比如常用的比较器这样写。

	/*常用的包含x,y节点的node的class*/
	class nodexy
	{
		int x,y;
		nodexy(){}
		nodexy(int xx, int yy)
		{
			x = xx;
			y = yy;
		}
	}

	/*使用这样的比较函数*/
	static Comparator<nodexy> cmp = new Comparator<nodexy>() 
	{
		public int compare(nodexy o1, nodexy o2) {
			// TODO Auto-generated method stub
			if (o1.x==o2.x)	return o1.y-o2.y;
			return o1.x-o2.x;
		}
	};

下面是一个简单的TreeMap的样例：

	public static void main(String args[])	throws IOException
	{	
		Map<Integer, Integer>q = new TreeMap<Integer, Integer>();	//int,int类型的TreeMap,没有包含比较器！
		q.put(1, 1);
		q.put(2, 2);
		q.put(3, 3);
		q.put(3, 4);	//重复的key的value只保留最后一个~ key才是关键字
		q.put(-1,0);
		q.put(-11,4);
		q.put(12,2);
		@SuppressWarnings("rawtypes")	//消除下面的警告信息
		Iterator it = q.entrySet().iterator();	//和C++一样用迭代器遍历
		System.out.print("size = " + q.size()+"\n");		//总元素数量
		while (it.hasNext())
		{
			@SuppressWarnings("unchecked")	//消除下面的警告信息
			Map.Entry<Integer, Integer> ent = (Entry<Integer, Integer>) it.next();
			int key = ent.getKey();	//key
			int value = ent.getValue(); //value
			System.out.println(key+" " + value);
		}
	}

	public static void main(String args[])	throws IOException
	{	
		TreeMap<Integer, Integer>q = new TreeMap<Integer, Integer>();	//int,int类型的TreeMap,没有包含比较器！
		q.put(1, 1);
		q.put(2, 2);
		q.put(3, 3);
		q.put(3, 4);	//重复的key的value只保留最后一个~ key才是关键字
		q.put(-1,0);
		q.put(-11,4);
		q.put(12,2);
		@SuppressWarnings({ "rawtypes", "unused" })	//消除下面的警告信息
		Iterator it = q.entrySet().iterator();	//和C++一样用迭代器遍历
		System.out.print("size = " + q.size()+"\n");		//总元素数量
		
		/*
		 * 不需要输出一次啦,直接这样
		while (it.hasNext())
		{
			@SuppressWarnings("unchecked")	//消除下面的警告信息
			Map.Entry<Integer, Integer> ent = (Entry<Integer, Integer>) it.next();
			int key = ent.getKey();	//key
			int value = ent.getValue(); //value
			System.out.println(key+" " + value);
		}
		*/
		int ans = q.get(12);
		System.out.println(ans);	//输出了2
		
		/*对于不存在的键值的处理， 先判断是否是null*/
		if (q.get(13) != null)
		{
			ans = q.get(13);
			System.out.println(ans);	
		}else System.out.println("nothing");//输出了nothing
		
		System.out.println(q.higherKey(4));//比4大的是12，所以输出12
		System.out.println(q.higherKey(12));//比12大的没有，输出null
		System.out.println(q.lastKey());	//输出最后一个key,也就是12，也是对的
		
		q.remove(2);	//删除键为2的
		if (q.get(2) != null)
		{
			ans = q.get(2);
			System.out.println(ans);	
		}else System.out.println("nothing");//因为2被删了，所以输出了nothing
		
	}


关于遍历，访问，删除迭代器指向内容的话


	public static void main(String args[])	throws IOException
	{	
		TreeMap<Integer, Integer>q = new TreeMap<Integer, Integer>();	//int,int类型的TreeMap,没有包含比较器！
		q.put(1, 1);
		q.put(2, 2);
		q.put(3, 3);
		q.put(3, 4);	//重复的key的value只保留最后一个~ key才是关键字
		q.put(-1,0);
		q.put(-11,4);
		q.put(12,2);
		@SuppressWarnings({ "rawtypes", "unused" })	//消除下面的警告信息
		Iterator it = q.entrySet().iterator();	//和C++一样用迭代器遍历
		System.out.print("size = " + q.size()+"\n");		//总元素数量
		
		
		while (it.hasNext())
		{
			@SuppressWarnings("unchecked")	//消除下面的警告信息
			Map.Entry<Integer, Integer> ent = (Entry<Integer, Integer>) it.next();
			int key = ent.getKey();	//key
			int value = ent.getValue(); //value
			if (key==-1 || key == 1 || key==12)it.remove();	//删除迭代器这个值，并且向后迭代！
			System.out.println(key+" " + value);
		}
		System.out.println();
		System.out.println();
		/*再出输出一次，发现-1，1,12都已经被删啦！*/
		it = q.entrySet().iterator();
		while (it.hasNext())
		{
			@SuppressWarnings("unchecked")	//消除下面的警告信息
			Map.Entry<Integer, Integer> ent = (Entry<Integer, Integer>) it.next();
			int key = ent.getKey();	//key
			int value = ent.getValue(); //value
			System.out.println(key+" " + value);
		}
	}<span style="white-space:pre">	</span>


/*下面例子依然是TreeMap,但是我们修改了key为一个class, 同时设置了比较函数~，比较经典*/
class Pack
{
	int a, b;
	Pack(){}
	Pack(int x, int y)
	{
		a=x;
		b=y;
	}
	boolean same(Pack tmp)
	{
		if (tmp.a == a && tmp.b==b)	return true;
		return false;
	}
};


public class Doit {
	
	//一边访问，一边删除迭代器指向的内容
	
	static Comparator<Pack> cmp = new Comparator<Pack>() {
		@Override
		public int compare(Pack o1, Pack o2) {
			// TODO Auto-generated method stub
			if (o1.a==o2.a)	return o1.b-o2.b;
			return o1.a-o2.a;
		}
	};

	
	public static void main(String args[])	throws IOException
	{	
		TreeMap<Pack, Integer>q = new TreeMap<Pack, Integer>(cmp);	//int,int类型的TreeMap,没有包含比较器！
		q.put(new Pack(1,1), 1);
		q.put(new Pack(2,2), 2);
		q.put(new Pack(2,3), 3);
		q.put(new Pack(1,-1), 4);	//重复的key的value只保留最后一个~ key才是关键字
		q.put(new Pack(5,2),0);
		q.put(new Pack(5,3),4);
		q.put(new Pack(4,2),2);
		q.put(new Pack(4,2),2);		
		@SuppressWarnings("rawtypes")
		Iterator it = q.entrySet().iterator();	//和C++一样用迭代器遍历
		System.out.print("size = " + q.size()+"\n");		//总元素数量，输出为7个
		
		
		while (it.hasNext())
		{
			@SuppressWarnings("unchecked")	//消除下面的警告信息
			Map.Entry<Pack, Integer> ent = (Entry<Pack, Integer>) it.next();
			Pack key = ent.getKey();
			int key1 = ent.getKey().a;	//key
			int key2 = ent.getKey().b;
			int value = ent.getValue(); //value
			if (key.same(new Pack(5,3)) || key.same(new Pack(2,2)))it.remove();	//删除迭代器这个值，并且向后迭代！ 
			System.out.println(key1+" "+key2+" " + value);
		}
		System.out.println();
		System.out.println();
		
		/*再出输出一次，发现-1，1,12都已经被删啦！*/
		it = q.entrySet().iterator();
		while (it.hasNext())
		{
			@SuppressWarnings("unchecked")	//消除下面的警告信息
			Map.Entry<Pack, Integer> ent = (Entry<Pack, Integer>) it.next();
			Pack key = ent.getKey();
			int key1 = ent.getKey().a;	//key
			int key2 = ent.getKey().b;
			int value = ent.getValue(); //value
			System.out.println(key1+" "+key2+" " + value);
		}
	}
}

===============================================大分割线=========================


实现c++的vector功能的arraylist.


用一个class的例子


class Pack
{
	int a, b;
	Pack(){}
	Pack(int x, int y)
	{
		a=x;
		b=y;
	}
	boolean same(Pack tmp)
	{
		if (tmp.a == a && tmp.b==b)	return true;
		return false;
	}
};


public class Doit {
	
	//一边访问，一边删除迭代器指向的内容
	
	static Comparator<Pack> cmp = new Comparator<Pack>() {
		@Override
		public int compare(Pack o1, Pack o2) {
			// TODO Auto-generated method stub
			if (o1.a==o2.a)	return o1.b-o2.b;
			return o1.a-o2.a;
		}
	};

	
	public static void main(String args[])	throws IOException
	{	
		ArrayList<Pack>q = new ArrayList<Pack>();
		q.add(new Pack(5,5));//塞入队尾
		q.add(new Pack(4,4));
		q.add(new Pack(7,7));
		System.out.println(q.get(0).a + " " + q.get(0).b);
		System.out.println(q.get(1).a + " " + q.get(1).b);
		System.out.println(q.get(2).a + " " + q.get(2).b);
		//Pack sb[] = q.toArray();
		
		Pack sb[];
		sb = q.toArray(new Pack[q.size()]);	//转换成数组
		for (int i = 0; i != q.size(); ++ i)
		{
			System.out.println(sb[i].a);
		}
		
	}
}



关于数组排序：

class Pack
{
	int a, b;
	Pack(){}
	Pack(int x, int y)
	{
		a=x;
		b=y;
	}
	boolean same(Pack tmp)
	{
		if (tmp.a == a && tmp.b==b)	return true;
		return false;
	}
};


public class Doit {
	
	//一边访问，一边删除迭代器指向的内容
	

	static Comparator<Pack> cmp = new Comparator<Pack>() {
		
		@Override
		public int compare(Pack o1, Pack o2) {
			// TODO Auto-generated method stub
			if (o1.a==o2.a)	return o1.b-o2.b;
			return o1.a-o2.a;
		}
	};
	
	
	public static void main(String args[])	throws IOException
	{	
		ArrayList<Pack>q = new ArrayList<Pack>();
		q.add(new Pack(5,5));//塞入队尾
		q.add(new Pack(4,4));
		q.add(new Pack(7,7));
		q.add(new Pack(4,3));
		q.add(new Pack(4,2));
		q.add(new Pack(4,10));
		q.add(new Pack(4,4));
		/*访问arraylist内元素方法用get*/
		System.out.println(q.get(0).a + " " + q.get(0).b);	
		System.out.println(q.get(1).a + " " + q.get(1).b);
		System.out.println(q.get(2).a + " " + q.get(2).b);
		//Pack sb[] = q.toArray();
		
		/*arraylist转化为数组*/
		Pack sb[];
		sb = q.toArray(new Pack[q.size()]);	//转换成数组
		/*
		for (int i = 0; i != q.size(); ++ i)
		{
			System.out.println(sb[i].a);
		}
		*/
		/*数组排序的方法*/
		Arrays.sort(sb,0, q.size(),cmp);   //排序，[L,R)区间进行排序。 例子是[0,q.size()) 之间的数字进行排序
		for (int i = 0; i != q.size(); ++ i)	//输出了数组中的元素，从小到大
		{
			System.out.println(sb[i].a + " " + sb[i].b);
		}
	}
}


容器的排序：

class Pack
{
	int a, b;
	Pack(){}
	Pack(int x, int y)
	{
		a=x;
		b=y;
	}
	boolean same(Pack tmp)
	{
		if (tmp.a == a && tmp.b==b)	return true;
		return false;
	}
};


public class Doit {
	
	//一边访问，一边删除迭代器指向的内容
	

	static Comparator<Pack> cmp = new Comparator<Pack>() {
		
		@Override
		public int compare(Pack o1, Pack o2) {
			// TODO Auto-generated method stub
			if (o1.a==o2.a)	return o1.b-o2.b;
			return o1.a-o2.a;
		}
	};
	
	
	public static void main(String args[])	throws IOException
	{	
		ArrayList<Pack>q = new ArrayList<Pack>();
		q.add(new Pack(5,5));//塞入队尾
		q.add(new Pack(4,4));
		q.add(new Pack(7,7));
		q.add(new Pack(4,3));
		q.add(new Pack(4,2));
		q.add(new Pack(4,10));
		q.add(new Pack(4,4));
		q.add(new Pack(2,4));
		/*访问arraylist内元素方法用get*/
		System.out.println(q.get(0).a + " " + q.get(0).b);	
		System.out.println(q.get(1).a + " " + q.get(1).b);
		System.out.println(q.get(2).a + " " + q.get(2).b);
		//Pack sb[] = q.toArray();
		System.out.println();
		System.out.println();
		System.out.println();
		
		
		Collections.sort(q,cmp);
		Iterator it = q.iterator();
		while (it.hasNext())
		{
			Pack tmp = (Pack) it.next();
			System.out.println(tmp.a+" "+tmp.b);
		}
		
	}
}


================================

另一种做比较器的方法 用接口实现：

class Pack
{
	int a, b;
	Pack(){}
	Pack(int x, int y)
	{
		a=x;
		b=y;
	}
	boolean same(Pack tmp)
	{
		if (tmp.a == a && tmp.b==b)	return true;
		return false;
	}
};

class MyCmp implements Comparator<Pack>
{
	//@Override
	public int compare(Pack o1, Pack o2) {
		// TODO Auto-generated method stub
		if (o1.a==o2.a)	return o1.b-o2.b;
		return o1.a - o2.a;
	}
}


public class Doit {
	
	//一边访问，一边删除迭代器指向的内容
	

	static Comparator<Pack> cmp = new MyCmp();
	
	
	public static void main(String args[])	throws IOException
	{	
		ArrayList<Pack>q = new ArrayList<Pack>();
		q.add(new Pack(5,5));//塞入队尾
		q.add(new Pack(4,4));
		q.add(new Pack(7,7));
		q.add(new Pack(4,3));
		q.add(new Pack(4,2));
		q.add(new Pack(4,10));
		q.add(new Pack(4,4));
		q.add(new Pack(2,4));
		/*访问arraylist内元素方法用get*/
		System.out.println(q.get(0).a + " " + q.get(0).b);	
		System.out.println(q.get(1).a + " " + q.get(1).b);
		System.out.println(q.get(2).a + " " + q.get(2).b);
		//Pack sb[] = q.toArray();
		System.out.println();
		System.out.println();
		System.out.println();
		
		
		Collections.sort(q,cmp);
		Iterator it = q.iterator();
		while (it.hasNext())
		{
			Pack tmp = (Pack) it.next();
			System.out.println(tmp.a+" "+tmp.b);
		}
		
	}
}


===========分界线===========================================================

POJ 2386 挑战P32 BFS/DFS搜索裸题 queue使用方法
static Queue<Coordinate> queue = new LinkedList<Coordinate>();//队列必须new LinkedList类型
    queue.offer(new Coordinate(arg0, arg1)); 塞入新元素

    queue.poll();//弹出头元素

    long nowx = queue.peek().x; //peek读取头元素


没有什么好说的 
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.security.Principal;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.LinkedList;
import java.util.Queue;
 
public class Main
{
	static InputReader reader = new InputReader(System.in);
    static PrintWriter writer = new PrintWriter(System.out);
	static long n, m;
	static char map[][] = new char [150][150];
	static Queue<Coordinate> queue = new LinkedList<Coordinate>();
    static boolean vis[][] = new boolean[150][150];
    final static long dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
    final static long dy[] = {-1, 1, 0, 0, -1, 1, -1, 1};
    //false为没哟放，true为访问过
    
	public static void main(String args[])
	{
		try
		{
			init();
			doit();
		}catch (IOException e){
			
			System.out.println("chuwenti");
		}
		finally 
		{
			writer.close();
		}
	}
	
	
	static void init()	throws IOException
	{
		for (int i = 0; i != 150; ++ i)
			for (int j = 0; j != 150; ++ j)
				vis[i][j] = false;
		n = reader.nextInt();
		m = reader.nextInt();
		for (int i = 0; i != n; ++ i)
		{
			String tmp = reader.nextString();
			map[i] = tmp.toCharArray();
		}
		//debug 输出读入的数据监测是否正确
		/*
		for (int i = 0; i != n; ++ i)
		{
			for (int j = 0; j != m; ++ j)
				writer.print(map[i][j]);
			writer.print(‘\n‘);
		}
		*/
	}
	
	static void bfs(long arg0, long arg1)
	{
		queue.offer(new Coordinate(arg0, arg1));
		while (!queue.isEmpty())
		{
			long nowx = queue.peek().x;
			long nowy = queue.peek().y;
			queue.poll();
			for (int i = 0; i != 8; ++ i)
			{
				long willx = nowx + dx[i];
				long willy = nowy + dy[i];
				if (willx <0 || willy <0 || willx >= n || willy >= m)	continue;
				if (map[(int) willx][(int) willy] == ‘.‘)	continue;
				queue.offer(new Coordinate(willx, willy));
				map[(int) willx][(int) willy] = ‘.‘;
			}
		}
	}
	
	
	static void doit()
	{
		long ans = 0;
		for (int i = 0; i != n; ++ i)
			for (int j = 0; j != m; ++ j)
			{
				if (map[i][j] == ‘.‘)	continue;
				bfs(i, j);
				ans ++;
			}
		writer.println(ans);
	}
}
 
 
class InputReader {
    InputReader(InputStream in) {
        this.reader    = new BufferedReader(new InputStreamReader(in));
        this.tokenizer = new StringTokenizer("");
    }
 
    public String nextToken() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }
 
    public int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }
    public String nextString() throws IOException
    {
    	return nextToken();
    }
 
    private BufferedReader  reader;
    private StringTokenizer tokenizer;
}
 
class Coordinate
{
	long x, y;
	public Coordinate() {
		// TODO Auto-generated constructor stub
		x = -2;
		y = -2;
	}
	public Coordinate(long x, long y) {
		// TODO Auto-generated constructor stub
		this.x = x;
		this.y = y;
	}
}
====================分界线==============================


POJ 3253 挑战P47 贪心，JAVA heap注意事项, PrintWriter注意事项

static Comparator<Integer> myCmp = new MyCmp();
	static PriorityQueue<Integer> q = new PriorityQueue<Integer>(mkh,myCmp);
切记，构造函数第一个需要填写数字。否则在部分OJ编译失败。并且这个数字大小写11即可。

同时，PrintWriter必须close,否则无输出！

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
 
public class Main
{
	static Comparator<Integer> myCmp = new MyCmp();
	static PriorityQueue<Integer> q = new PriorityQueue<Integer>(20000,myCmp);
	static Integer num[] = new Integer[30000];
	static int n;
	static PrintWriter writer = new PrintWriter(System.out);
	static InputReader reader = new InputReader(System.in);
	
	public static void main(String args[])	throws IOException
	{
		
		init();
		doit();
	}
	
	static void init() throws IOException
	{
		n = reader.nextInteger();
		for (int i = 0; i != n; ++ i)
		{
			num[i] = reader.nextInteger();
		}
	}
	
	static void doit() 
	{
		//System.out.println("!");
		long ans = 0;
		for (int i = 0; i != n; ++ i)
			q.offer(num[i]);
		while (!q.isEmpty())
		{
			if (q.size() == 1)
			{
				break;
			}
			long arg0 = q.poll();
			long arg1 = q.poll();
			ans += arg0 + arg1;
			q.offer(Integer.valueOf( (int) (arg0 + arg1)));
		}
		writer.println(ans);
		writer.close();
	}
	
}
 
class MyCmp implements Comparator<Integer>
{
	//@Override
	public int compare(Integer o1, Integer o2) {
		// TODO Auto-generated method stub
		return o1 - o2;
	}
}
 
class InputReader
{
	public InputReader(InputStream in) {
		// TODO Auto-generated constructor stub
		this.reader = new BufferedReader(new InputStreamReader(in));
		this.tokenizer = new StringTokenizer("");
	}
	public String nextTokenizer()	throws IOException
	{
		while (!tokenizer.hasMoreTokens())
		{
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
	public Integer nextInteger() throws IOException
	{
		return Integer.valueOf(nextTokenizer());
	}
	private StringTokenizer tokenizer;
	private BufferedReader reader;
	
}
=============分割线==================

POJ 1182 挑战P89 并查集 食物链 关于new 对象数组

static Animal animal[] = new Animal[50010];
for (int i = 0; i != 50010; ++ i)    animal[i] = new Animal();
必须这样，否则并不能初始化！！！！

并查集还得练！思考不够详细！

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Main
{
	static int n, m;
	static InputReader reader = new InputReader();
	static Animal animal[] = new Animal[50010];
	public static void main(String args[])	throws IOException
	{
		initAndDoit();
	}
	
	public static void initAndDoit()	throws IOException
	{
		n = reader.nextInt();
		m = reader.nextInt();
		for (int i = 0; i != 50010; ++ i)	animal[i] = new Animal();
		int ans = 0;
		for (int test = 0; test != m; ++ test)
		{
			int flag = reader.nextInt();
			int a = reader.nextInt(), b = reader.nextInt();
			if (a > n || b > n) //满足条件2和条件3，假话
			{
				++ ans;
				continue;
			}
			
			int x = getFather(a);
			int y = getFather(b);
			
			if (flag == 1) //同类
			{
				if (x == y)	
				{
					if (animal[a].relationship != animal[b].relationship)	ans ++;
					continue;
				}
				animal[x].father = y;
				animal[x].relationship = (animal[b].relationship - animal[a].relationship + 3) % 3;
 
			}
		
			if (flag == 2) //a吃b
			{
				if (x == y)
				{
					if ((animal[a].relationship ) !=  (animal[b].relationship + 1) % 3)
					{
						ans ++;
					}
				}else 
				{
					animal[x].father = y;
					animal[x].relationship = (animal[b].relationship - animal[a].relationship + 4) % 3;
				}
			}
		}
		System.out.println(ans);
	}
	
	public static int getFather(int arg0)
	{
	//	System.out.println(arg0 + " " + animal[arg0].father);
		int index = animal[arg0].father;
		if (index == -1)	return arg0;
		int relationship = animal[arg0].relationship;
		//System.out.println(index + " " + arg0);
		animal[arg0].father = getFather(index);
		animal[arg0].relationship = (relationship + animal[index].relationship) % 3;
		return animal[arg0].father;
	}
	
	
}
 
class Animal
{
	int father;
	int relationship;
	Animal()
	{
		this.father = -1;
		this.relationship = 0;
	}
}
 
 
class InputReader
{
	InputReader()
	{
		this.reader = new BufferedReader(new InputStreamReader(System.in));
		this.tokenizer = new StringTokenizer("");
	}
	public String nextTokenizer() throws IOException
	{
		while (!tokenizer.hasMoreTokens())
		{
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}
	
	public int nextInt() throws IOException
	{
		return Integer.valueOf(nextTokenizer());
	}
	
	
	private StringTokenizer tokenizer;
	private BufferedReader reader;
}

ACM等算法比赛中JAVA 常用"STL"总结:TreeMap,Queue,PriorityQueue等

标签：

原文地址：http://blog.csdn.net/baidu_23081367/article/details/51505185
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！