蓝桥杯模拟题 前向距离+和谐向量对（Java）

前向距离

给定一个序列 a_1, a_2, …, a_n。其中 a_1 是最大的数，没有其他数与 a_1 相等。

对于从第二个数开始的每个数 a_i，请找到位置在 a_i 之前且比 a_i 大的，位置上距离 a_i 最近的数 a_j。称为 a_i 的前向距离。

对于给定的序列，请求出所有数的前向距离之和。

输入：

输入的第一行包含一个整数 n，表示序列的长度。

第二行包含 n 个正整数，为给定的序列。

输出：

输出一个整数，表示序列中所有数的前向距离之和。

样例输入

8

9 1 3 5 2 7 6 3

样例输出

14

import java.util.Scanner;

public class Main4{
	public static void main(String[]args){
		Scanner s=new Scanner(System.in);
		int m=s.nextInt();
		int[] a=new int[m];
		//max记录除第一个数的最大值，max_i记录max的下标，sum记录最终的所有的前向距离之和
		int max=0,max_i=0,sum=0;
		for (int i = 0; i < a.length; i++) {
			a[i]=s.nextInt();
		}
		for (int i = 1; i < a.length; i++) {
			//当现在这个数比前一个数小则直接+1
			if(a[i-1]>a[i]){sum++;}
			//当现在这个数大于max则它只比第一个数小，就加下标表示其中的距离
			else if(a[i]>max){sum+=i;}
			//当现在这个数小于max时就从当前坐标往后移动比较大小直到遇到max
			else {
				int n=i;
				while(n>max_i){
					n--;
					if(a[n]>a[i]){
						sum+=i-n;
						break;
						}
				}
			}
			if(max<a[i]){max=a[i];max_i=i;}
			System.out.println(sum);
		}
	}
}

和谐向量对

一个平面向量表示从一个坐标点到另一个坐标点的变化量，一般用两个数(x, y)来表示。

两个向量相加是指分别将对应的两个数相加，例如(x_1, y_1)与(x_2, y_2)相加后得(x_1 + x_2, y_1 + y_2)。

如果两个向量相加后，得到的向量两个值相等，我们称这写两个向量为和谐向量对。例如(3, 5)和(4, 2)是和谐向量对。

给定 n 个向量，问能找到多少个和谐向量对？

输入：

输入的第一行包含一个整数 n，表示向量的个数。

接下来的 n 行，每行两个整数 x_i, y_i， 表示一个向量。

输出：

输出一个整数，表示有多少个和谐向量对。

请注意，自己和自己不能成为一个和谐向量对。

样例输入

5

9 10

1 3

5 5

5 4

8 6

样例输出

2

样例输入

4

1 1

2 2

1 1

2 2

样例输出

6

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.Map.Entry;

public class Main2 {
	public static void main(String[] args) {
		Scanner s =new Scanner(System.in);
		int n=s.nextInt();
		int[] a=new int[n];
		int[] b=new int[n];
		int sum=0,c=0;
		HashMap<Integer,Integer> map1=new HashMap<Integer,Integer>();
		for (int i = 0; i < n; i++) {
			a[i]=s.nextInt();
			b[i]=s.nextInt();
			//将输入值的差存储
			b[i]=a[i]-b[i];
			//再将其值和它的个数存入HashMap中备用
			if(map1.containsKey(b[i])){
				c=map1.get(b[i])+1;
				map1.put(b[i], c);
			}
			else{map1.put(b[i], 1);}
		}
		/*0比较特殊，单独计算。
		 * 0的相反数还是0，所以先将0的组合个数算出，这里应该乘2但是乘4是因为最后计算sum时除了2所以这里再乘个2
		 * */
		if(map1.containsKey(0)){
			sum+=(map1.get(0)-1)*4;
			map1.remove(0);
			}
		//遍历HashMap计算其中互为相反数的值的个数乘积。
		Iterator <Entry<Integer,Integer>> b1=map1.entrySet().iterator();
		while(b1.hasNext()){
			Map.Entry e=(Map.Entry)b1.next();
			int key=(int) e.getKey();
			if(map1.containsKey(-key)){
				sum+=map1.get(-key)*map1.get(-key);
				}
		}
		//这里sum/2是因为上面的计算中一个值为正数时计算了一次乘积，为负数时也计算了一次乘积，总共计算了两次
		System.out.println(sum/2);
	}
}

记录。