杭电复试 —— 2015年

题目一：

package Y2015;
import java.util.Scanner;

/*
 * 题目一：
	给定一个字符串,计算字符串中数值的个数并求和。
	其中还包含了负号，若紧跟负号的是一个数值，	则表示这是一个负数，若后面跟着的不是数字，则不表示什么。
	输入：一个字符串
	输出：数值个数数值和列子 
	
	输入：312ab-2-9-a (要算上整个数字的，而不是单独的每一位一个数字)
	输出：3 301 
 */
public class P2015_1 {
	public static void main(String[] args) {
		Scanner sn = new Scanner(System.in);
		String s = sn.next();
		int sum = 0,temp; //数字求和
		int count = 0; //数字个数统计
		int i,j;
		for(i = 0;i < s.length();i++) {
			if(s.charAt(i) == '-' && Character.isDigit(s.charAt(i+1))) { //负数
				 temp = 0;
				 for(j=1;i+j < s.length() && Character.isDigit(s.charAt(i+j));j++) {
		                temp= temp*10+s.charAt(i+j)-48;//临时存一个数
				 }
		         i=i+j-1; // 下一次就略过这个数字，从下面一个开始去做
		         //System.out.println("负数" + temp + " " + sum);
		         sum-=temp;
		         count++;
			} else if(Character.isDigit(s.charAt(i))) { //正数
				 temp = 0;
				 for(j=0;i+j < s.length() && Character.isDigit(s.charAt(i+j));j++) {
		                temp= temp*10+s.charAt(i+j)-48;//临时存一个数 
				 }
		         i=i+j-1; // 下一次就略过这个数字，从下面一个开始去做
		         //System.out.println("正数" + temp + " " + sum);
		         sum+=temp;
		         count++;
			}
		}
		System.out.println(count + " " + sum);
		
		sn.close();
	}

}

题目二：（BFS\DFS）重点看

package Y2015;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

/*
   给定一个数字矩阵，如果上下左右(只要有一个满足即可) 数值相同，则表示是一个连通的区域。求矩阵中连通块的数量。
   输入：
         先是矩阵的行数和列数接着是矩阵
   输出：
         连通块的数量 
	例子 
5 6 
4 4 4 4 4 4 
4 2 3 3 1 4 
4 2 2 3 1 4 
4 2 3 3 1 4 
4 4 4 4 4 4 
输出 
4

4 5
4 5 5 5 5
4 3 3 3 5
2 3 3 3 5
1 3 3 3 5
输出 
5

说明所有4能连起来，还有2 3 1，都有各自能连通块。
	
	 
public class P2015_2_BFS {
	public static int MAX = 1010;	
	public static int X[] = { 0, 0, 1, -1 }, 
			Y[] = { 1, -1, 0, 0 };//代表四个方向
	//静态变量的初始化是在数组之前的，如果我只是定义一个MAX，而没有给它赋值，那它就是0，这个数组的大小也只是char[0][0]
	public static int[][] map = new int[MAX][MAX]; 
	public static int n, m; //矩阵长度
	public static boolean[][] visit = new boolean[MAX][MAX];//标记数组

	public static Loc now = new Loc(); //实例化两个对象
	public static Loc temp = new Loc();

	public static void main(String[] args) {
		Scanner sn = new Scanner(System.in);
		int ans = 0;//表示连通数
		n = sn.nextInt();
		m = sn.nextInt();
		for (int i = 0; i < n; i++) { //数组初始化
			for (int j = 0; j < m; j++) {
				map[i][j] = sn.nextInt();
			}
		}
		
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (!visit[i][j]) {// 如果还没被访问过，就说明肯定还有连通块儿
					ans++;
					BFS(i, j, map[i][j]); //去进行访问
				}
			}
		}
		System.out.println(ans);
		
		sn.close();
	}

	public static boolean judge(int x, int y, int value) {// value标记现在表示通路的字符
		if (x >= n || y >= m || x < 0 || y < 0)// 越界
			return false;
		if (visit[x][y])// 如果已经访问过了
			return false;
		if (map[x][y] == value)// 如果该位置的值也是通路上的值
			return true;
		return false;
	}

	public static void BFS(int x, int y, int value) {
		now.x = x;
		now.y = y;
		now.value = value;

		Queue<Loc> q = new LinkedList<>(); //peek() poll() offer()
		
		q.offer(now); //将当前的点存入队列
		visit[x][y] = true; //置当前点为已访问过
		
		while (!q.isEmpty()) {//队列不为空
			now = q.peek(); //队头元素
			q.poll(); //对头出队
			for (int i = 0; i < 4; i++) {
				temp.x = now.x + X[i]; //上下左右四个方向逐步判断
				temp.y = now.y + Y[i];//就是新的坐标出错了
				//System.out.println(temp.x+" "+temp.y);
				if((temp.x < n && temp.x >= 0) && (temp.y < m && temp.y >= 0))	{			
				    temp.value = map[temp.x][temp.y]; //找到各种方向后的数组中当前的点的值
				    //temp.value与 now.value判断
					if (judge(temp.x, temp.y, now.value)) {
						q.offer(new Loc(temp.x, temp.y, temp.value)); //这里一定要记住是要新建对象
						visit[temp.x][temp.y] = true;
					}
				}
				
			}
		}
	}
}

//为每一个点赋一个结构体
class Loc {
	public int x;
	public int y;
	public int value;
	public Loc() {
		
	}
	public Loc(int x, int y, int value) {
		super();
		this.x = x;
		this.y = y;
		this.value = value;
	}
	
}

package Y2015;

import java.util.Scanner;

public class P_2015_2_DFS {
	public static int N = 101;//一个数组实例化大小标记
	public static boolean[][] visit = new boolean[N][N];//标记是否访问过该节点 
	public static int DFS_COUNT;//记录有多少个连通分量 
	public static int X[]={0,0,1,-1},Y[]={1,-1,0,00};//坐标转移数组 
	public static int n,m;//输入图的大小 
	public static int[][] map = new int[N][N];//用来存储图  
	
	public static void main(String[] args) {
		Scanner sn = new Scanner(System.in);
		n = sn.nextInt();
		m = sn.nextInt();
	    for(int i=0;i<n;i++) { //存储图 
	        for(int j=0;j<m;j++) {
	           map[i][j]=sn.nextInt(); 
	        }
	    }
	    //进行深搜
	    for(int i=0;i<n;i++) {
	        for(int j=0;j<m;j++) {//对整个图进行遍历 
	            if(!visit[i][j]){               
	                DFS_COUNT++;
	                dfs(i,j);//更换坐标 一条路一直 走到尽头       
	            }
	        }
	    }
	    System.out.println(DFS_COUNT);//输出连通个数
	    sn.close();
	}
	
	//判断能否继续往前走
	public static boolean judge(int x,int y,int value){
	    if(x>=n||x<0||y>=m||y<0)//如果越界就返回false 
	        return false;
	    if(visit[x][y])//如果访问过 
	        return false;
	    if(map[x][y]==value)//如果字符相同才表示这一条是通路 
	        return true;
	    return false; 
	}
	
	public static void dfs(int x,int y){
	    visit[x][y]=true;
	    for(int i=0;i<4;i++ ){//进行图的上下左右的遍历 
	        int newx=x+X[i];
	        int newy=y+Y[i];
	        if(judge(newx,newy,map[x][y]))//如果该位置满足条件就递归 
	            dfs(newx,newy);
	    }       
	}
		
}