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

最新推荐文章于 2024-01-23 21:52:55 发布
最新推荐文章于 2024-01-23 21:52:55 发布
阅读量3.7k 收藏 5
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_23081367/article/details/51505185
版权

第一个：显然是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;
    
    

    
    

     
     }

CMTM4
关注
JAVA常用STL
TmikuJ的学习笔记
02-19 1181
文章目录输入与输出1.输入2.输出3.文件读写大整数与高精度1.大整数BigInteger2.高精度BigDecimal字符串与进制转换1.字符串基本操作2.进制转换数据结构1.set2.map3.vector(list)4.priority_queue5.queue6.stack 输入与输出 1.输入 基本输入 Scanner sc=new Scanner(System.in); Scann...
ACM常用算法模版（常用函数与STL、重要公式与定理）
Li5566123的博客
10-24 885
如果格子[i, j]有元素a[i, j],则[i+1, j]要么没有元素, 要么a[i+1, j] > a[i, j]从浙大同学那偷的acm的一些板子，与大家分享。priority_queue 优先队列, empty(), top(), pop(), push()queue 队列, empty(), front(), pop(), push()stack 栈, empty(), top(), pop(), push()sort() 排序, O(N log(N))
java 集合（2）：TreeMap，WeakHashMap，HashTable，ArrayDeque，PriorityQueue
Mr_tianyanxiaobai的博客
08-10 338
八、 TreeMap（线程不安全） 在前面我们通过HashMap中插入顺序无序引出了LinkedHashMap的使用，但是我们又可以发现，这两种存储方式在迭代时均不是按照数据的大小顺序进行遍历的，而当我们需要将数据按照大小顺序迭代时，就需要此时的TreeMap集合了。 TreeMap是一个大小有序的key-value集合，底层结构是红黑树，不允许插入null值。 TreeMap采用红黑树的插入和删除方法，通过比较key决定新元素的插入位置，也通过红黑树的有序性质进行删除。 TreeMap需要通过 Comp
TreeSet TreeMap ProityQueue LinkedList个人理解
zuyunfanwoerzi的博客
09-17 276
TreeSet TreeMap ProityQueue LinkedList 这是四种在处理数据时常用到集合或者队列，它们的特点就是会对放进去的数据按照默认或者自定义的 规则进行排序，不过它们在处理速度，接受数据类型或者格式各有优劣; **TreeSet与PriorityQueue：**这两个一起说是因为它们使用方式类似，使用的场合也类似，底层算法也类似，都是二叉树，都可以通过默认或者自定义比较器对存入的元素进行排序，并且可以使用poll方法移除并返回头部元素，使用add或者offer存入元素，TreeSe
对二维数组自定义排序、Treemap自定义排序、priorityqueue自定义排序
qq_41358574的博客
03-22 674
二维数组自定义排序 Arrays.sort(intervals,new Comparator<int[]>() { @Override public int compare(int[]a,int[]b) { return a[0]==b[0]?b[1]-a[1]:a[0]-b[0]; } }); Treemap自定义排序 Map map = new TreeMap(); map.put("a", "ddddd"); map.put("c", "bbbbb"); map.put("
java常见STL
qq_42794545的博客
03-06 3721
Table of Contents 算法竞赛中的JAVA使用笔记输入与输出基本输入输入挂输出控制台输入输出重定向到文件大整数与高精度大整数BigInteger高精度BigDecimal字符串与进制转换字符串基本操作进制转换排序默认排序实现Comparator接口自定义比较器对自定义类的排序用lambda自定义比较器(仅 JAVA8 以上支持)C++STL中部分数据结构在JAVA中对应的用法s...
ACM中常用STL
01-31
ACM 中常用的 STL STL（Standard Template Library，标准模板库）是 C++ 程序设计语言的标准库之一，提供了多种常用的数据结构和算法，以提高编程效率和代码复用性。下面将对常用的 STL 进行介绍，包括 vector、set...
2016年ACM常用算法总结
01-11
1. **经典算法集合**：这一节可能讲述了一些基础且在ACM竞赛中常用的算法，这些算法是解决各种问题的基础。 2. **动态规划（DP）**：动态规划是一种在数学、管理科学、计算机科学、经济学和生物信息学等领域中用于...
ACM/NOI/CSP比赛经验分享：历年算法总结
最新发布
03-04
ACM/NOI/CSP比赛经验分享：历年算法总结（不包含代码，仅有算法名称）
ACM常用算法(重要)
04-04
ACM常用算法(重要)ACM常用算法(重要)ACM常用算法(重要)ACM常用算法(重要)ACM常用算法(重要)ACM常用算法(重要)ACM常用算法(重要)ACM常用算法(重要)ACM常用算法(重要)
堆结构的优秀实现类----PriorityQueue优先队列
热门推荐
Walker_YAM
06-05 1万+
之前的文章中，我们有介绍过动态数组ArrayList，双向队列LinkedList，键值对集合HashMap，树集TreeMap。他们都各自有各自的优点，ArrayList动态扩容，数组实现查询非常快但要求连续内存空间，双向队列LinkedList不需要像ArrayList一样创建连续的内存空间，它以链表的形式连接各个节点，但是查询搜索效率极低。HashMap存放键值对，内部使用数组加链表实现，检索
JAVA TreeSet TreeMap Queue Deque PriorityQueue
半睡半醒半浮生
12-04 385
[code="java"] public static void main(String[] args) { List list = Arrays.asList(45,23,12,88,5,16); NavigableSet nset = new TreeSet(list); System.out.println(nset); for(Iterator itr...
LeetCode 347 Top K Frequent Elements (HashMap && TreeMap 或 PriorityQueue 推荐)
Tc的专栏
11-06 1745
LeetCode 347 Top K Frequent Elements (HashMap && TreeMap 或 PriorityQueue 推荐)
2020大一寒假ACM培训⑦（queue队列篇）
无名小秃瓢的博客
02-12 218
队列的基本操作： （1）初始化队列 queue<int>vis,定义一个队列 操作 代码实现 入队 vis.push(x) 出队 vis.pop() 判断队列是否为空 vis.empty() 判断队列中元素的数量 vis.size() 得到队首元素 vis.front() 得到队尾元素 vis.back() （6）得到队列的队首元素 vis.fr...
STL容器在ACM中的一些用法
一只冰熊
09-20 878
今天突然想起前几个月刚接触STL容器的时候不知道从哪里下手，又找不到教程。现在就写一点自己使用STL容器的体会，希望给大家一些帮助。 以后会慢慢加上例题（如果我还能回想起我挖过这个坑的话 vector vector是一个可变长的数组。 用法： vector 名字;  例如  vector ve;  vector ve; 自己定义的结构体什么
STL容器与算法 （七）Priority Queues(优先队列)知识点
diviner_s的博客
02-18 635
文章目录C++ Priority Queues C++ Priority Queues
《疯狂Java讲义（第4版）》-----第8章【Java集合】（Queue）
ccnuacmhdu的博客
10-03 255
Queue 队列啦！一般不可随机访问队列中的元素。Queue官方文档如下： PriorityQueue 优先队列，学过数据结构应该就清楚是根据堆排序原理实现的。查看官方文档，PriorityQueue的构造器可以传入Comparator对象，这说明可以自己去定义排序的方法，由于之前在TreeSet部分已经详细说明。此处不在赘述。 import java.util.PriorityQueue; ...
ACM/ICPC竞赛之STL--queue
逐梦者
06-25 2723
ACM模版stack（栈）和queue（队列）是在程序设计中经常会用到的数据容器，STL为我们提供了方便的stack（栈）和queue（队列）的实现。准确的说，STL中的stack和queue不同于vector、list等容器，而是对这些容器进行了重新的包装。这里我们不去深入讨论STL的stack和queue的实现细节，而是来了解一些他们的基本使用。queuequeue模版类的定义在<queue>头
红黑树的应用 - TreeMap、LinkedHashMap、PriorityQueue
善守者
01-23 1110
继续插入节点 30：当前节点 (0030)、父节点 (0025) 和叔叔节点 (0037) 都为红色，所以可以将当前节点的祖先 (0035) 的状态传递给子节点，变成上图第二个状态。继续插入节点 26：可以看到，现在的状态是，当前节点 (0026) 和父节点 (0030) 为红色，当前节点为左子树，父节点为右子树，并且叔叔节点并不为红色（组成一个大于号）。这时候我们也需要右旋，以当前节点为支点，将其父节点作为当前节点的右节点，当前节点重新充当其祖父节点的右节点，状态从图一转为图二。
ACM竞赛中常用的STL算法：deque操作详解
"ACM竞赛中常用的STL容器与算法实践" 在ACM（国际大学生程序设计竞赛）中，掌握高效且灵活的编程技巧是至关重要的，而STL（Standard Template Library，标准模板库）提供了丰富的数据结构和算法，极大地简化了代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值