《蓝桥杯》蓝桥杯研究生A组复习（代码经过测试，可以完美运行）

1.Eclipse自动提示快捷键设置

2.输入输出

public static void main(String[] args) throws IOException {
		//第一种
		
		int m,n,k;
		long l;
		/*
		Scanner cin=new Scanner(System.in);
		m=cin.nextInt();
		l=cin.nextLong();
		System.out.println(m+" "+l);
		cin.close();
		*/
		//第二种
		BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
		//加快输入 对应其它parseLong,
		String  str=bfr.readLine();
		String s[]=str.split(" ");
		n=Integer.parseInt(s[0]);
		k=Integer.parseInt(s[1]);
		
		System.out.println(n+" "+k);
	}

3.BigInteger：

package test;

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

	public static void main(String[] args) throws IOException {
	  Scanner cin = new Scanner(System.in);
      	BigInteger a;
        BigInteger b;
        while(cin.hasNext()){
 
        a = cin.nextBigInteger();
 
        b = cin.nextBigInteger();
 
        System.out.println(a.add(b)); //大整数加法
 
        System.out.println(a.subtract(b)); //大整数减法
 
        System.out.println(a.multiply(b)); //大整数乘法
 
        System.out.println(a.divide(b)); //大整数除法(取整)
 
        System.out.println(a.remainder(b)); //大整数取模
 
        if( a.compareTo(b) == 0 ) System.out.println("a == b"); //大整数a==b
else if( a.compareTo(b) > 0 ) System.out.println("a > b"); //大整数a>b
else if( a.compareTo(b) < 0 ) System.out.println("a < b"); //大整数a<b
 
	    System.out.println(a.abs()); //大整数a的绝对值
	 
        int exponent=10;
 
        System.out.println(a.pow(exponent)); //大整数a的exponent次幂
 
        System.out.println(a.toString());
 
        //返回大整数p进制的字符串表示
        int p=8;
 
        System.out.println(a.toString(p));
	}

	}
	}

4.全排列：

import java.io.*;
import java.math.BigInteger;
import java.util.*;



public class Main {
	
	public static int num=0;
	static void swap(char c[],int index1,int index2)//用数组来实现数值的交换
	{
		char temp=c[index1];
		c[index1]=c[index2];
		c[index2]=temp;	
	}
	
	static void Perm(char c[],int k,int n)
	{
		if(k==n)
		{
			num++;
			for(int i=0;i<=n;i++)
			{
				System.out.print(c[i]+" ");
			}
			System.out.println();
		}
		else{
			for(int i=k;i<=n;i++)
			{
				swap(c,i,k);
				Perm(c, k+1, n);
				swap(c,i,k);
			}
		}
	}
	
public static void main(String[] args) throws IOException {
		BufferedReader bfr =new BufferedReader(new InputStreamReader(System.in));
		String str =bfr.readLine();
		str=str.replace(" ", "");
		char c[]=str.toCharArray();
		num=0;
		Perm(c,0,c.length-1);
		System.out.println(num);
	}
}

5.集合(hashMap,Set)

package test;

import java.io.*;
import java.math.BigInteger;
import java.util.*;


public class Main {
	
public static void main(String[] args) throws IOException {
	Map<String,String> map=new HashMap();                
    map.put("a", "aaa");    
    map.put("d", "ddd"); 
    map.put("b", "bbb");    
    map.put("c", "ccc");    
       
    Iterator<String> iter =map.keySet().iterator();
    while(iter.hasNext())
    {
    	String str=iter.next();
    	System.out.println(str+" "+map.get(str));
    }
        
 
    //两种方式    
    Map<String,String> tmp=new TreeMap();                    
    tmp.put("a", "aaa");      
    tmp.put("d", "ddd");
    tmp.put("b", "bbb");    
    tmp.put("c", "ccc");  
    for(String s : tmp.keySet())
    	System.out.println(s+" "+map.get(s));
	
    Set<String> set1=new TreeSet<String>();
	set1.add("ADAD");
	set1.add("ADAD");
	set1.add("DAD");
	Iterator<String> iter1=set1.iterator();
	while(iter1.hasNext())
	{
		String s1=iter1.next();
		System.out.println(s1);
	}
	for(String val:set1)
	{
		System.out.println(val);
	}    
	
}
		
}

6.优先队列

import java.io.*;
import java.math.BigInteger;
import java.util.*;


public class Main {
	public static class Coordinate implements Comparable<Coordinate> {
		int x,y;
		public Coordinate(int x,int y) {
			this.x=x;
			this.y=y;
		}
		@Override
		public int compareTo(Coordinate o) {
			return o.x==this.x?this.y-o.y:this.x-o.x;
		}
	}
	
public static void main(String[] args) throws IOException {
	PriorityQueue<Coordinate> pq =new PriorityQueue();
	pq.add(new Coordinate(1,4));
	pq.add(new Coordinate(1,3));
	pq.add(new Coordinate(0,1));
	while(!pq.isEmpty())
	{
		System.out.println(pq.peek().x+" "+pq.peek().y);
		pq.poll();
	}
	
	return;
}
		
}

7.dfs bfs

8.多维排序

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


public class Main {
	public static class Coordinate implements Comparable<Coordinate> {
		int x,y;
		public Coordinate(int x,int y) {
			this.x=x;
			this.y=y;
		}
		@Override
		public int compareTo(Coordinate o) {
			return o.x==this.x?this.y-o.y:this.x-o.x;
		}
	}
	
public static void main(String[] args) throws IOException {
	Coordinate a[]=new Coordinate[3];
	a[0]=new Coordinate(1,4);
	a[1]=new Coordinate(1,3);
	a[2]=new Coordinate(0,1);
	Arrays.sort(a);
	for(Coordinate i:a)
	{
		System.out.println(i.x+" "+i.y);
	}
	List<Coordinate>arr=new ArrayList<Coordinate>();
	arr.add(new Coordinate(1,4));
	arr.add(new Coordinate(1,3));
	arr.add(new Coordinate(0,1));
	for(Coordinate i:arr)
	{
		System.out.println(i.x+" "+i.y);
	}
	Collections.sort(arr);
	for(Coordinate i:arr)
	{
		System.out.println(i.x+" "+i.y);
	}
	return;
}
		
}

9.并查集

蓝桥杯历届试题 合根植物 并查集 java实现

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


public class Main {
	final static int maxn=1000000;
	static HashMap<Integer, Integer>map=new HashMap<Integer, Integer>();
	static int count=0;//树的数量
	static int find(int i)//返回i的根节点
	{
		while(i!=map.get(i))
			i=map.get(i);//找根节点 根节点的根是自己
		return i;
	}
	
	static void union(int i,int j)
	{
		int ri=find(i);
		int rj=find(j);
		if(ri!=rj)
			{	
				map.put(rj,ri);//rj的根节点变为ri 从而实现合并
				count--;//此时树的数量减1
			}
		return;
	}
	public static void main(String[] args) throws IOException {
		int m,n,k;
		BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
//加快输入
		String  str=bfr.readLine();
		String s[]=str.split(" ");
		m=Integer.parseInt(s[0]);
		n=Integer.parseInt(s[1]);
		str=bfr.readLine();
		s=str.split(" ");
		k=Integer.parseInt(s[0]);
		
		map=new HashMap<Integer, Integer>();
		for(int i=1;i<=m*n;i++)//初始化，每一个结点的根结点都是自己
			map.put(i, i);
		
		count=m*n;//开始时有多少个结点，就有多少棵树
		for(int i=1;i<=k;i++)
		{
			str=bfr.readLine();
			s=str.split(" ");
			int a=Integer.parseInt(s[0]);
			int b=Integer.parseInt(s[1]);
			union(a,b);
		}
 
		System.out.println(count);
	}
}

10.进制转换

 
 
public class Main {
 
	public static void main(String[] args) {
		int a=11;
		String s="11";
		
		//当然不仅仅是Integer Long也可以
		//多进制转化为10进制
		for(int i=2;i<20;i++)
			System.out.println(Integer.valueOf(s, i)+" "+Integer.parseInt(s, i));
                //两种方式都可以
		System.out.println();
		
		//10进制转化为多进制
		for(int i=2;i<20;i++)
		{
			System.out.println(Integer.toString(a, i));
		}
		//比较特殊的2 8 16进制有特别的函数
		System.out.println(Integer.toHexString(a));//将10转换为十六进制，返回字符串类型
		System.out.println(Integer.toOctalString(a));//将10转为八进制，返回字符串类类型
		System.out.println(Integer.toBinaryString(a));//将10转为二进制，返回字符串类型
		
				
	}
 
}

11.快速幂

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

public class Main {
	//计算a的b次方
	public static int  qPow(int a,int b) {
		int base=a;
		int re=1;
		while(b!=0)
		{
			if((b&1)==1)
				re*=base;
			base*=base;
			b=b>>1;
		}
		return re;
	}

	public static void main(String[] args) throws IOException {
		
		System.out.println(qPow(3, 4));
	}		
}

12.拓扑排序

浅谈图论之拓扑排序

 
 
import java.io.*;
import java.util.*;
 
/*
//example:2 
2 
RY Unknown 
YSZ RY 
3 
tomorrow yestoday 
tomorrow today 
today yestoday 
*/
public class Main {
 
	static ArrayList<Integer> list=new ArrayList<Integer>();//存放结果
	static ArrayList<Integer>edge[]=new ArrayList[105];//存放每个顶点对应的边
	static HashMap<String,Integer> map=new HashMap<String,Integer>();
//实现string与整数标号的转换
	static int inDegree[]=new int[105];//入度
	
	static void init()//初始化
	{
		list.clear();
		map.clear();
		for(int i=0;i<105;i++)
			edge[i] = new ArrayList<Integer>();
		Arrays.fill(inDegree, 0);
	}
	static String intToString(int i,HashMap<String,Integer> map)
//最后将整数标号转化为对应的值
	{
		Iterator<String> iterator=map.keySet().iterator();
		while(iterator.hasNext())
		{
			String key=iterator.next();
			if(map.get(key)==i)
				return key;
		}
		return null;
	}
	//拓扑排序
	static void topologicalSort(HashMap<String,Integer> map,ArrayList<Integer>edge[],int inDegree[],ArrayList<Integer> list,int count)
	{
		Queue<Integer>q=new LinkedList<Integer>();
		Iterator<String> iterator=map.keySet().iterator();
		while(iterator.hasNext())
		{
			String key=iterator.next();
			if(inDegree[map.get(key)]==0)//找到入度为0的点压入队列
				q.add(map.get(key));
		}
		while(!q.isEmpty())
		{
			int now=q.poll();
			list.add(now);//输出入度为0的点
			for(int i=0;i<edge[now].size();i++)
//把由此节点发出的所有边消除，即边的终点入度减一
			{
				inDegree[edge[now].get(i)]--;
				if(inDegree[edge[now].get(i)]==0)//如果上次操作产生了入度为0的顶点，压入队列
					q.add(edge[now].get(i));
			}
		}
		if(list.size()!=count)
		{
			System.out.println("Error：存在环！");
			return;
		}
		System.out.println();
		for(int i=0;i<list.size();i++)
		{
			if(i==0)
				System.out.print(intToString(list.get(i),map));
			else
				System.out.print(" "+intToString(list.get(i),map));
		}
		//System.out.println();
	}
	
	public static void main(String[] args) throws IOException {
	BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
	String str=bfr.readLine();
	String s[]=str.split(" ");
	int n=Integer.parseInt(s[0]);
	for(int i=0;i<n;i++)
	{
		str=bfr.readLine();
		s=str.split(" ");
		int m=Integer.parseInt(s[0]);
		init();
		int count=0;
		for(int j=0;j<m;j++)
		{
			str=bfr.readLine();
			s=str.split(" ");
			String first=s[0];
			String second=s[1];
			//每个字符串对应一个整数代号
			//System.out.println(first+" "+second);
			if(!map.containsKey(first))
				map.put(first, count++);
			if(!map.containsKey(second))
				map.put(second, count++);
			
			inDegree[map.get(second)]++;//second 入度加1
			edge[map.get(first)].add(map.get(second));
		}
		
		topologicalSort(map,edge,inDegree,list,count);
	}
 
	}
 
}

13、最小生成树

package test;

import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Scanner;
/*
4
1 4 5 8
WPL: 33
*/

public class a {
	
	static class node implements Comparable<node>{//自排序
		 
		int weight;//权值
		node lchild;
		node rchild;
		public node(int w,node l,node r)
		{
			this.weight=w;
			this.lchild=l;
			this.rchild=r;
		}
		
		public int compareTo(node o) {
			return this.weight-o.weight;
		}
	}
	
	
	static node createHuffmanTree(PriorityQueue<node> nodes)
	{
		while(nodes.size()>1)
		{	
			node l=nodes.peek();
			nodes.poll();
			node r=nodes.peek();
			nodes.poll();
			//System.out.println(l.weight+" "+r.weight);
			node p=new node(l.weight+r.weight,l,r);
		
			//把大的放进去
			nodes.add(p);
		}
		return nodes.peek();
	}
	
	//前序遍历，并求WPL 带权路径长度
	static long WPL=0;
	static void preorder(node root,int levelNum)
	{
		if(root.lchild==null)
		{
			WPL+=root.weight*levelNum;
			return;
		}
		else
		{
			preorder(root.lchild,levelNum+1);
			preorder(root.rchild,levelNum+1);
		}
		
	};
	
	
	public static void main(String[] args) {
		PriorityQueue<node> nodes=new PriorityQueue<>();
		Scanner cin=new Scanner(System.in);
		int n=cin.nextInt();
		for(int i=0;i<n;i++)
		{
			int w=cin.nextInt();//这里我直接把它的权值当做name了
			nodes.add(new node(w,null,null));
		}
		node r=createHuffmanTree(nodes);
		
		WPL=0;//WPL:带权路径长度
		preorder(r,0);
		System.out.println("WPL: "+WPL);
		cin.close();
	}

}

14、最短路的几种算法 （Dijkstra，spfa，floyd）

谈谈最短路的几种算法 （Dijkstra，spfa，floyd） 并附上蓝桥杯 最短路的代码实现

15、归并排序

package test;
public class Main {
    public static void main(String[] args) {
        int[] ans = {6, 8, 4, 4, 6, 36, 673, 13, 6, 7, 3, 4, 6, 8, 3, 7, 5, 7, 9, 5};
        System.out.print("原数组：");
        for (int i = 0; i < ans.length; i++) {
            System.out.print(ans[i]+",");
        }
        System.out.println();
        mergeSort(ans);
        System.out.print("归并排序之后的数组：");
        for (int i = 0; i < ans.length; i++) {
            System.out.print(ans[i]+",");
        }
    }

    //sort方法的驱动程序
    private static void mergeSort(int[] ans) {
        sort(ans, 0, ans.length - 1);
    }

    //将tmp和Cctr当做参数传入，方便调用merge方法时获得这两个参数
    private static void sort(int[] ans, int left, int right) {
        int mid = (left + right) / 2;
        //当分到只剩下一个元素的情况,则退出递归程序
        if (left >= right) {
            return;
        }
        sort(ans, left, mid);
        sort(ans, mid + 1, right);
        merge(ans, left, mid, right);
    }

    private static void merge(int[] ans, int left, int mid, int right) {
        //声明三个计时器
        int Actr = left;
        int Bctr = mid + 1;
        int Cctr = 0;
        int lenA = mid - left + 1;
        int lenB = right - mid;
        //创建临时数组,长度为A，B数组长度之和
        int[] tmp = new int[right - left + 1];
        //循环A，B中长度较短的长度次数的二倍的次数
        while (Actr <= mid && Bctr <= right) {
            if (ans[Actr] <= ans[Bctr]) {
                tmp[Cctr++] = ans[Actr];
                Actr++;
            } else {
                tmp[Cctr++] = ans[Bctr];
                Bctr++;
            }
        }
        //如果左边的还有剩余，将左边剩余的归并
        while (Actr <= mid){
            tmp[Cctr ++] = ans[Actr ++];
        }
        //如果右边的还有剩余，将右边剩余的归并
        while (Bctr <= right){
            tmp[Cctr ++] = ans[Bctr ++];
        }
        //将临时数组更新到原数组
        for (int i = 0; i < tmp.length; i++) {
            ans[left++] = tmp[i];
        }
    }
}

16、堆排序

public class HeapSorting {
       public static void main(String[] args) {
		     int[] a=new int[]{0,9,8};
		     Sort(a,a.length-1);
		     for(int i:a){
		    	 System.out.println(i);
		     }
	   }
       public static void MaxHeapify(int[] a,int index,int size){
    	   int l=2*index;
    	   int r=2*index+1;
    	   int largest=index;
    	   if(l<=size && a[l]>a[index]){
    		   largest=l;
    	   }
    	   if(r<=size && a[r]>a[largest]){
    		   largest=r;
    	   }
    	   if(largest!=index){
    		   int temp=a[largest];
    		   a[largest]=a[index];
    		   a[index]=temp;
    		   MaxHeapify(a,largest,size);
    	   }
       }
       public static void HeapBuild(int[] a,int size){
    	   for(int i=size/2;i>=1;i--){
    		   MaxHeapify(a,i,size);
    	   }
       }
       public static void Sort(int[] a,int size){
    	   HeapBuild(a,size);
    	   for(int i=size;i>=2;i--){
    		   int temp=a[i];
    		   a[i]=a[1];
    		   a[1]=temp;
    		   MaxHeapify(a,1,i-1);
    	   }
       }
}