蓝桥杯14天冲刺(Java)

2024-03-28数据结构与算法143 分钟338 次阅读
AI 摘要salmon-ai

本文详细解析了蓝桥杯14天冲刺中的多道Java题目

1.手算与思维题

编程1 门牌制作

题目描述

本题为填空题,只需要算出结果后,在代码中使用输出语句将所填结果输出即可。

小蓝要为一条街的住户制作门牌号。

这条街一共有2020 位住户,门牌号从1到2020编号。

小蓝制作门牌的方法是先制作0到9这几个数字字符,最后根据需要将字符粘贴到门牌上,例如门牌 1017 需要依次粘贴字符1、0、1、7,即需要1个字符0,2个字符 1, 1个字符7。

请问要制作所有的1到2020号门牌,总共需要多少个字符2?

运行限制
image.png

题解

按官方的提示,就是直接打印1到2020的数字,然后将结果粘贴至一个空文件中,用编辑器打开该文件,查询有关2的字符,就会显示有多少个2。
image.png
当然,用代码解决也很简单。

java 复制代码
// 门牌制作
public class Main {
	public static void main(String[] args) {
		int count = 0;
		for (int i = 1; i <= 2020; i++) {
			String s = new String(i + "");
			for (char c : s.toCharArray()) {
				if (c == '2') {
					count++;
				}
			}
		}
		System.out.print(count);
	}
}

编程2 迷宫

题目描述

本题为填空题,只需要算出结果后,在代码中使用输出语句将所填结果输出即可。

X星球的一处迷宫游乐场建在某个小山坡上。它是由 10 × 10 相互连通的小房间组成的。
房间的地板上写着一个很大的字母。我们假设玩家是面朝上坡的方向站立,则:

  • L 表示走到左边的房间,
  • R 表示走到右边的房间,
  • U 表示走到上坡方向的房间,
  • D 表示走到下坡方向的房间。

X星球的居民有点懒,不愿意费力思考。他们更喜欢玩运气类的游戏。这个游戏也是如此!

开始的时候,直升机把 100名玩家放入一个个小房间内。玩家一定要按照地上的字母移动。

迷宫地图如下:
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR

请你计算一下,最后,有多少玩家会走出迷宫,而不是在里边兜圈子?

如果你还没明白游戏规则,可以参看下面一个简化的 4x4 迷宫的解说图:
image.png

运行限制
image.png

题解

java 复制代码
// 迷宫
public class Main {

	static String[][] graph = new String[12][12];
	static int count = 0; // 累计有多少个玩家走出迷宫

	public static void main(String[] args) {
		String[] arr = new String[10];
		arr[0] = "UDDLUULRUL";
		arr[1] = "UURLLLRRRU";
		arr[2] = "RRUURLDLRD";
		arr[3] = "RUDDDDUUUU";
		arr[4] = "URUDLLRRUU";
		arr[5] = "DURLRLDLRL";
		arr[6] = "ULLURLLRDU";
		arr[7] = "RDLULLRDDD";
		arr[8] = "UUDDUDUDLL";
		arr[9] = "ULRDLUURRR";
		for (int i = 1; i < 11; i++) {
			String str = arr[i - 1];
			for (int j = 1; j < 11; j++) {
				graph[i][j] = str.charAt(j - 1) + "";
			}
		}
		for (int i = 1; i < 11; i++) {
			for (int j = 1; j < 11; j++) {
				dfs(i, j);
			}
		}
		System.out.print(count);
	}

	/**
	 * 深度搜索
	 * 
	 * @param x 纵向
	 * @param y 横向
	 */
	private static void dfs(int x, int y) {
		if (check(x, y)) {
			count++;
			return;
		}
		String str = graph[x][y]; // 拿到当前位置的方向
		if ("L".equals(str)) {
			String next = graph[x][y - 1];
			if ("R".equals(next)) {
				return;
			}
			dfs(x, y - 1);
		} else if ("R".equals(str)) {
			String next = graph[x][y + 1];
			if ("L".equals(next)) {
				return;
			}
			dfs(x, y + 1);

		} else if ("U".equals(str)) {
			String next = graph[x - 1][y];
			if ("D".equals(next)) {
				return;
			}
			dfs(x - 1, y);
		} else if ("D".equals(str)) {
			String next = graph[x + 1][y];
			if ("U".equals(next)) {
				return;
			}
			dfs(x + 1, y);
		}
	}

	/**
	 * 校验是否在迷宫外
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private static boolean check(int x, int y) {
		if (x == 0 || x == 11 || y == 0 || y == 11) {
			return true;
		}
		return false;
	}
}

编程3 星期一

题目描述

本题为填空题,只需要算出结果后,在代码中使用输出语句将所填结果输出即可。

整个 20世纪(1901年1月1日至2000年12月31日之间),一共有多少个星期一?(不要告诉我你不知道今天是星期几)

运行限制
image.png

题解

计算这期间闰年与平年天数的和,为36525天,36525/7=5217,一共有5217个周末,余数为6,由于2000-12-31那天是周日,往前推6天,则是周日、...、周二,则最后的这一周期是不包含周一的,故一共有5217个周一。

java 复制代码
public class Main {
	public static void main(String[] args) {
		int sum = 0;
		for (int i = 1901; i <= 2000; i++) {
			if (isRun(i)) {
				// 闰年
				sum += 366;
			} else {
				// 平年
				sum += 365;
			}
		}
		System.out.println("一共多少天:" + sum);
		System.out.println("sum/7:" + sum / 7);
		System.out.println("sum%7:" + sum % 7);
	}

	/**
	 * 判断是否闰年
	 * 
	 * @return
	 */
	private static boolean isRun(int year) {
		return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
	}
}

用 python 更方便,填空题可以用任何语言。

python 复制代码
from datetime import*
dt1=datetime(1901,1,1)
dt2=datetime(2000,12,31)

print(dt1.weekday())
# 周一为0,周二为1...

td=dt2-dt1

print(td.days//7)

编程4 乘积尾零

题目描述

本题为填空题,只需要算出结果后,在代码中使用输出语句将所填结果输出即可。

如下的10 行数据,每行有 10 个整数,请你求出它们的乘积的未尾有多少个零?

sh 复制代码
5650 4542 3554 473 946 4114 3871 9073 90 4329 
2758 7949 6113 5659 5245 7432 3051 4434 6704 3594 
9937 1173 6866 3397 4759 7557 3070 2287 1453 9899 
1486 5722 3135 1170 4014 5510 5120 729 2880 9019 
2049 698 4582 4346 4427 646 9742 7340 1230 7683 
5693 7015 6887 7381 4172 4341 2909 2027 7355 5649 
6701 6645 1671 5978 2704 9926 295 3125 3878 6785 
2066 4247 4800 1578 6652 4616 1113 6205 3264 2915 
3966 5291 2904 1285 2193 1428 2265 8730 9436 7074 
689 5510 8243 6114 337 4096 8199 7313 3685 211 

运行限制
image.png

题解

java 复制代码
import java.math.BigInteger;

//  乘积尾零
public class Main {
	public static void main(String[] args) {
		String[] str = new String(
				"5650 4542 3554 473 946 4114 3871 9073 90 4329 " + "2758 7949 6113 5659 5245 7432 3051 4434 6704 3594 "
						+ "9937 1173 6866 3397 4759 7557 3070 2287 1453 9899 "
						+ "1486 5722 3135 1170 4014 5510 5120 729 2880 9019 "
						+ "2049 698 4582 4346 4427 646 9742 7340 1230 7683 "
						+ "5693 7015 6887 7381 4172 4341 2909 2027 7355 5649 "
						+ "6701 6645 1671 5978 2704 9926 295 3125 3878 6785 "
						+ "2066 4247 4800 1578 6652 4616 1113 6205 3264 2915 "
						+ "3966 5291 2904 1285 2193 1428 2265 8730 9436 7074"
						+ "689 5510 8243 6114 337 4096 8199 7313 3685 211 ")
				.split(" ");
		BigInteger sum = BigInteger.ONE;
		for (int i = 0; i < str.length; i++) {
			sum = sum.multiply(new BigInteger(str[i]));
		}
		System.out.println(sum);
		int count = 0;
		// 末尾连续0的个数,故对10取模应为0
		while (sum.mod(new BigInteger("10")).intValue() == 0) {
			count++;
			sum = sum.divide(new BigInteger("10"));
		}
		System.out.println(count);
	}
}

编程5 付账问题

题目描述

几个人一起出去吃饭是常有的事。但在结帐的时候,常常会出现一些争执。

现在有 n{n} 个人出去吃饭,他们总共消费了 S{S} 元。其中第 i{i} 个人带了 ai{a_i} 元。幸运的是,所有人带的钱的总数是足够付账的,但现在问题来了:每个人分别要出多少钱呢?

为了公平起见,我们希望在总付钱量恰好为S{S} 的前提下,最后每个人付的钱的标准差最小。这里我们约定,每个人支付的钱数可以是任意非负实数,即可以不是1 分钱的整数倍。你需要输出最小的标准差是多少。

标准差的介绍:标准差是多个数与它们平均数差值的平方平均数,一般用于刻画这些数之间的"偏差有多大"。形式化地说,设第 i{i} 个人付的钱为 bi{b_i} 元,那么标准差为:
image.png

输入描述
第一行包含两个整数 n{n}、S{S};
第二行包含 n{n} 个非负整数 a1{a_1},...,an{a_n}。
其中,1≤5×105,0≤ai≤10{1\leq5\times10^5,0\leq a_i\leq10}。

输出描述
输出最小的标准差,四舍五入保留 4位小数。
保证正确答案在加上或减去10−9{10^{-9}}后不会导致四舍五入的结果发生变化。

输入输出样例
示例

输入

sh 复制代码
5 2333
666 666 666 666 666

输出

sh 复制代码
0.0000

运行限制
image.png

题解

这里的话,每个人付费分情况讨论:

  • 当前用户携带的钱未达到待付款的平均值,这类用户需要把所有的钱拿出来付款,才对其它用户公平(使其它用户尽量不用帮未待足钱的用户付超出平均值太多)
  • 当前用户携带的钱刚好达到待付款的平均值,则该用户刚好把携带的所有钱交出即可,这类用户不需要更有钱的人垫付。
  • 当前用户携带的钱超过待付款的平均值,则可以帮之前比较贫穷的用户(未达到平均值)分摊他们剩下未付款的部分。

根据题目所提供的公式,我们计算出每个用户的付款金额与平均值的方差,并累加起来,最后求出平均方差的平方根,则为标准差。

java 复制代码
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(); // 人数
		long s = sc.nextLong(); // 消费了多少钱
		long a[] = new long[n]; // 存储每个人携带的钱
		for (int i = 0; i < n; i++)
			a[i] = sc.nextLong();
		Arrays.sort(a); // 从小到大排序
		double ans = 0, avg;
		avg = (double) s / n; // 平均分摊金额

		for (int i = 0; i < n; i++) {
			int num = n - i; // 剩余未支付的人数

			// 如果剩余未支付的人数 * 当前用户携带的金额 能填补剩余需要还的钱
			if (num * a[i] >= s) {
				// 则剩余用户就均摊剩余未还的钱即可
				// 因为金额从小到大排序,后面的用户肯定比当前用户还有钱
				// 所以后面用户的方差都一样
				ans += num * Math.pow((double) s / num - avg, 2);
				break;
			} else {
				// 计算当前用户的方差
				ans += Math.pow(a[i] - avg, 2);
				// 相当于当前用户掏空钱包还钱
				s -= a[i];
			}
		}
		// 所有用户的方差的平均数的平方根
		System.out.printf("%.4f\n", Math.sqrt(ans / n));
	}
}

2. 工具函数模板

编程6 CLZ银行问题

题目描述

CLZ{CLZ} 银行只有两个接待窗口,VIP{VIP} 窗口和普通窗口,VIP{VIP} 用户进入VIP{VIP} 窗口排队,剩下的进入普通窗口排队。现有 M{M} 次操作,操作有四种类型,如下:

  • IN name V:表示一名叫 name 的用户到 VIP{VIP} 窗口排队
  • OUT V:表示 VIP{VIP} 窗口队头的用户离开排队
  • IN name N:表示一名叫 name 的用户到普通窗口排队
  • OUT N: 表示普通窗口队头的用户离开排队

求 M{M} 次操作结束后 VIP{VIP} 窗口队列和普通窗口队列中的姓名。

输入描述

第一行是一个整数 M(1≤M≤1000){M(1 \leq M \leq 1000)},表示一共有 M{M} 次操作。

第二行到第 M+1{M+1} 行输入操作,格式如下:

  • IN name V
  • OUT V
  • IN name N
  • OUT N

输出描述

输出 M{M} 次操作后 VIP{VIP} 窗口队列和普通窗口队列中的姓名(从头到尾),先输出 VIP{VIP} 窗口队列后输出普通窗口队列。

输入输出样例

示例

输入

sh 复制代码
5
IN xiaoming N
IN Adel V
IN laozhao N
OUT N
IN CLZ V

输出

sh 复制代码
Adel
CLZ
laozhao

运行限制
image.png

题解

java 复制代码
import java.util.*;

// CLZ银行问题
public class Main {
	public static void main(String[] args) {
		Queue<String> vQueue = new LinkedList<>(); // VIP队列
		Queue<String> nQueue = new LinkedList<>(); // 普通队列
		Scanner sc = new Scanner(System.in);
		int m = sc.nextInt();
		while (m> 0) {
			String str = sc.nextLine();
			if ("".equals(str)) {
				continue;
			}
			m--;
			String[] arr = str.split(" ");
			if (arr.length == 3) {
				String name = arr[1];
				if ("V".equals(arr[2])) {
					vQueue.offer(name);
				} else {
					nQueue.offer(name);
				}
			} else if (arr.length == 2) {
				if ("V".equals(arr[1])) {
					vQueue.poll();
				} else {
					nQueue.poll();
				}
			}
		}
		while (!vQueue.isEmpty()) {
			System.out.println(vQueue.poll());
		}
		while (!nQueue.isEmpty()) {
			System.out.println(nQueue.poll());
		}
	}
}

编程7 费里的语言

题目描述

小发明家弗里想创造一种新的语言,众所周知,发明一门语言是非常困难的,首先你就要克服一个困难就是,有大量的单词需要处理,现在弗里求助你帮他写一款程序,判断是否出现重复的两个单词。

输入描述

第 1{1} 行,输入 N{N},代表共计创造了多少个单词。

第 2{2} 行至第 N+1{N+1} 行,输入 N{N} 个单词。

1≤N≤104{1\leq N\leq10^4},保证字符串的总输入量不超过 106{10^6}。

输出描述
输出仅一行。若有重复的单词,就输出重复单词,没有重复单词,就输出 NO,多个重复单词输出最先出现的。

输入输出样例

示例1

输入

sh 复制代码
6
1fagas 
dsafa32j
lkiuopybncv
hfgdjytr
cncxfg
sdhrest

输出

sh 复制代码
NO

示例2

输入

sh 复制代码
5
sdfggfds
fgsdhsdf
dsfhsdhr
sdfhdfh
sdfggfds

输出

sh 复制代码
sdfggfds

运行限制
image.png

题解

java 复制代码
import java.util.*;

// 费里的语言
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		Set<String> sets = new HashSet<>();
		boolean flag = true;
		while (n > 0) {
			String word = sc.nextLine();
			if ("".equals(word)) {
				continue;
			}
			n--;
			if (sets.contains(word)) {
				System.out.println(word);
				flag = false;
				continue;
			}
			sets.add(word);
		}
		if (flag) {
			System.out.println("NO");
		}
	}
}

编程8 快递分拣

题目描述

蓝桥王国的每个快递都包含两个参数:1.快递单号2.快递城市。

小李是蓝桥王国的一名快递员,每天的快递分拣让他苦不堪言。

于是他想要你帮他设计一个程序用于快递的分拣(将不同快递按城市信息分开)。

输入描述

输入第一行包含一个整数 N{N},表示快递的个数。

接下来第 2{2} ~ N+1{N+1} 行每行包含一个字符串 S{S} 和一个字符串 P{P},分别快递单号以及快递对应的城市。

1≤N≤103{1\leq N\leq10^3},保证数据量不超过 106{10^6}。

输出描述

输出共若干行。按城市的输入顺序依次输出城市的名称以及城市的快递个数,以及该城市的所有快递单号(单号按照输入顺序排序)。

输入输出样例

示例

输入

sh 复制代码
10 
10124214 北京
12421565  上海
sdafasdg213 天津
fasdfga124 北京
145252  上海
235wtdfsg 济南
3242356fgdfsg 成都
23423 武汉  
23423565f 沈阳
1245dfwfs 成都

输出

sh 复制代码
北京 2
10124214
fasdfga124
上海 2
12421565
145252
天津 1
sdafasdg213
济南 1
235wtdfsg
成都 2
3242356fgdfsg 
1245dfwfs 
武汉 1
23423
沈阳 1
23423565f 

运行限制
image.png

题解

java 复制代码
import java.util.*;

// 快递分拣
public class Main {
	public static void main(String[] args) {
		Map<String, List<String>> map = new LinkedHashMap<>();
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		while (n-- > 0) {
			String order = sc.next();
			String city = sc.next();
			List<String> orders = map.get(city);
			if (orders == null) {
				orders = new ArrayList<>();
			}
			orders.add(order);
			map.put(city, orders);
		}
		for (Map.Entry<String, List<String>> entry : map.entrySet()) {
			String city = entry.getKey();
			List<String> orders = entry.getValue();
			System.out.println(city + " " + orders.size());
			for (String order : orders) {
				System.out.println(order);
			}
		}
	}
}

3. 枚举与尺取法

编程9 42点问题

题目描述

请你设计一个程序对该问题进行解答。

众所周知在扑克牌中,有一个老掉牙的游戏叫做 24{24} 点,选取 4{4} 张牌进行加减乘除,看是否能得出 24{24} 这个答案。

现在小蓝同学发明了一个新游戏,他从扑克牌中依次抽出6张牌,注意不是一次抽出,进行计算,看是否能够组成 42{42} 点,满足输出 YES,反之输出 NO。

最先抽出来的牌作为第一个操作数,抽出牌做第二个操作数,运算结果再当作第一个操作数,继续进行操作。

注:除不尽的情况保留整数,而且扑克牌的四张 10{10} 都丢了,不会出现 10{10},1和A都可能出现并表示1。

请设计一个程序对该问题进行解答。

输入描述

输出仅一行包含 6{6} 个字符。

保证字符 ∈{\in} 1 2 3 4 5 6 7 8 9 J Q K A。

输出描述

若给出到字符能够组成 42 点,满足输出 YES,反之输出 NO。

输入输出样例

示例

输入

sh 复制代码
K A Q 6 2 3 

输出

sh 复制代码
YES

运行限制
image.png

题解

这题的话我们可以对所有结果做枚举,每次拿到一张扑克,就与上一次拿的扑克的计算结果做一次计算(加减乘除),放于当前这一轮扑克的结果集中,之后下一轮拿的扑克,就与当前这一轮的计算结果做运算,然后继续反复直到所有扑克拿完为止。

之后我们拿完扑克后,我们将所有扑克组合的结果也都已经计算完了,我们只需看最后一轮拿到扑克后,是否有结果能组合成 42。

java 复制代码
import java.util.*;

// 42点问题
public class Main {
	public static void main(String[] args) {
		Map<String, Integer> map = new HashMap<>();
		map.put("1", 1);
		map.put("2", 2);
		map.put("3", 3);
		map.put("4", 4);
		map.put("5", 5);
		map.put("6", 6);
		map.put("7", 7);
		map.put("8", 8);
		map.put("9", 9);
		map.put("J", 11);
		map.put("Q", 12);
		map.put("K", 13);
		map.put("A", 1);

		Scanner sc = new Scanner(System.in);

		int[] puke = new int[6]; // 存放当前依次拿到的扑克

		for (int i = 0; i < 6; i++) {
			int num = map.get(sc.next());
			puke[i] = num;
		}

		// 用于枚举依次拿到的扑克牌的组合
		List<List<Integer>> list = new ArrayList<>();
		list.add(new ArrayList<Integer>()); // 存放第一张牌的运算情况
		list.get(0).add(puke[0]); // 添加第一张牌

		// 依次从枚举上一轮的结果与当前这一轮拿到的牌的计算结果
		for (int i = 1; i < 6; i++) {
			int cur = puke[i];
			list.add(new ArrayList<Integer>());
			int count = 0; // + - * /
			// 将上一轮枚举的数字继续与当前这一轮的数字做加减乘除,枚举所有可能的结果
			for (int last : list.get(i - 1)) {
				// 上一轮的运算结果当做第一个操作数,
				// 所以这里需要让上一轮的操作数放在第一位
				// 这样即使上一次的结果可能有0,分母也不会为0,因为扑克没有0
				list.get(i).add(last + cur);
				list.get(i).add(last - cur);
				list.get(i).add(last * cur);
				list.get(i).add(last / cur);
			}
		}

		boolean flag = false;
		// 拿到最后一轮的计算结果,如果其中有值是42的,就输出YES
		for (int last : list.get(5)) {
			if (last == 42) {
				flag = true;
				break;
			}
		}
		System.out.println(flag ? "YES" : "NO");
	}
}

编程10 公平抽签

题目描述

小A{A}的学校,蓝桥杯的参赛名额非常有限,只有 m{m} 个名额,但是共有 n{n} 个人报名。

作为老师非常苦恼,他不知道该让谁去,他在寻求一个绝对公平的方式。

于是他准备让大家抽签决定,即 m{m} 个签是去,剩下的是不去。

小 A{A}非常想弄明白最后的抽签结果会有多少种不同到情况,请你设计一个程序帮帮小 A{A}!

输入描述

输入第一行包含两个字符n{n},m{m},其含义如题所述。

接下来第二行到第 n+1{n+1} 行每行包含一个字符串S{S},表示个人名。

1≤m≤n≤15{1\leq m\leq n\leq15}。

输出描述

输出共若干行,每行包含 m{m} 个字符串,表示该结果被选中到人名(需按字符串的输入顺序大小对结果进行排序)。

输入输出样例

示例

输入

sh 复制代码
3 2
xiaowang
xiaoA
xiaoli

输出

sh 复制代码
xiaowang xiaoA
xiaowang xiaoli
xiaoA xiaoli

运行限制
image.png

这题是一道组合型枚举题,我们依次从n个元素中,随机选出m个元素进行组合。

组合型枚举题模板:

java 复制代码
import java.util.Scanner;
import java.util.Vector;
public class Main {

    static  int n;
    static int m;//选m个数
    static Vector<Integer> chosen = new Vector<Integer>();
    static  void calc(int x) {
        if (chosen.size() > m || chosen.size() + (n - x + 1) < m) //剪枝
            return;
        if (x == n + 1) { //选够了m个数输出
            String ansTem = "";
            for (int i = 0; i < chosen.size(); i++)
                System.out.print(chosen.get(i)+" ");
            System.out.println("");
            return;
        }
        chosen.addElement(x);
        calc(x + 1);
        chosen.remove((Object)x);
        calc(x + 1);
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        calc(1);
    }
}

题解

java 复制代码
import java.util.*;

// 公平抽签
public class Main {
	static String[] names;
	static List<String> ans = new ArrayList<>();
	static int n, m;
	static Vector<Integer> vistied = new Vector<>(); // 标记已选择的名字下标

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt(); // 报名人数
		m = sc.nextInt(); // 名额数
		names = new String[n];
		for (int i = 0; i < n; i++) {
			names[i] = sc.next();
		}
		calc(1);
		for (String str : ans) {
			System.out.println(str);
		}

	}

	/**
	 * 组合
	 * 
	 * @param x 当前处理的名字是第几个
	 */
	private static void calc(int x) {
		// 当前已选中的名字数已经超过名额数
		// 或者已选中的名字数,加之后剩余未选的名字数,以及加上当前这个名字,是否还达不到名额数
		if (vistied.size() > m || vistied.size() + (n - x + 1) < m) {
			return;
		}
		// 选够数量
		if (vistied.size() == m) {
			String item = "";
			// 从选中的名字里面做组合
			for (int i = 0; i < vistied.size(); i++) {
				item += names[vistied.get(i) - 1] + " ";
			}
			ans.add(item.trim();
			return;
		}
		// 标记当前已选择的名字
		vistied.addElement(x);
		// 去让当前选择的名字去与下一个名字组合
		calc(x + 1);
		// 取消标记
		vistied.removeElement(x);
		// 让下一个名字去与其他名字组合,当前名字不参与
		calc(x + 1);
	}
}

编程11 座次问题

题目描述

小A的学校,老师好不容易解决了蓝桥杯的报名问题,现在老师又犯愁了。

现在有 N{N} 位同学参加比赛,但是老师想给他们排座位,但是排列方式太多了。

老师非常想弄明白最后的排座次的结果是什么样子的,到底有多少种结果。

请设计一个程序帮助老师。

最后输出各种情况的人名即可,一行一种情况,每种情况的名字按照报名即输入顺序排序。

输入描述

输入第一行包含一个整数 N{N}。

接下来 N{N} 行每行包含一个字符串 Si{S_i},表示人名。

image.png

输出描述

输出共若干行,每行输出各种情况的人名。一行一种情况,每种情况的名字按照报名即输入顺序排序。

输入输出样例

示例

输入

sh 复制代码
3
xiaowang
xiaoA
xiaoli

输出

sh 复制代码
xiaowang xiaoA xiaoli
xiaowang xiaoli xiaoA
xiaoA xiaowang xiaoli
xiaoA xiaoli xiaowang
xiaoli xiaowang xiaoA
xiaoli xiaoA xiaowang

运行限制
image.png

这题是一道排列型枚举题,就是 n 个全排列,只是每次的内部顺序不一样。故需要有一个数组来做记录每次的顺序。

排列型枚举题模板代码:

java 复制代码
  static  int n;
  static int[] order =new int[20];
  static boolean[] chosen =new boolean[20];
  static <object> void calc(int x) {
      if (x == n + 1) { //选够了m个数输出
          String ansTem = "";
          for (int i = 1; i <=n ; i++)
              System.out.println(order[i]);
          return;
      }
      for (int i = 1; i <= n; i++) {
          if (chosen[i]) continue;
          order[x] = i;
          chosen[i] =true;
          calc(x + 1);
          chosen[i] = false;
          order[x] = 0;
      }
  }
  public static void main(String[] args) {
      Scanner in = new Scanner(System.in);
      n = in.nextInt();
      for (int i = 0; i < n; i++) {
         String s;
          s=in.next();
          name.addElement(s);
      }
      calc(1);
  }

题解

java 复制代码
import java.util.*;

// 座次问题
public class Main {

	static String[] names; // 名字
	static boolean[] vistied; // 已处理过的名字
	static int[] order; // 座位序号
	static int n; // 人数

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		names = new String[n];
		order = new int[n];
		vistied = new boolean[n];
		for (int i = 0; i < n; i++) {
			names[i] = sc.next();
		}
		calc(0);
	}

	/**
	 * 组合
	 * 
	 * @param x 当前处理的序号(从0开始)
	 */
	private static void calc(int x) {
		if (x == n) {
			String str = names[order[0]];
			for (int i = 1; i < n; i++) {
				str += " " + names[order[i]];
			}
			System.out.println(str);
			return;
		}
		// 访问所有节点
		for (int i = 0; i < n; i++) {
			if (vistied[i])
				continue;
			// 记录当前座位序号的名字(下标)
			order[x] = i;
			// 标记当前该名字已经处理,下一个序号的组合就不参与了
			vistied[i] = true;
			calc(x + 1);
			vistied[i] = false;
			order[x] = 0;
		}
	}

}

4. 递推法与递归法

编程12 数字三角形

题目描述

image.png

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径,把路径上面的数加起来可以得到一个和,你的任务就是找到最大的和(路径上的每一步只可沿左斜线向下或右斜线向下走)。

输入描述

输入的第一行包含一个整数 N(1≤N≤100){N(1\leq N\leq100)},表示三角形的行数。

下面的 N{N} 行给出数字三角形。数字三角形上的数都是0{0}至99{99}之间的整数。

输出描述

输出一个整数,表示答案。

输入输出样例

示例

输入

sh 复制代码
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

输出

sh 复制代码
30

运行限制
image.png

题解

这里假设我们从顶层往下走,走到了第 i 层,现在想选到达第 i+1 层的最大方向,那么肯定选两个路径中最大值的那一条前进。故其实我们可以从最下往上,先在倒数第二层统计好当前这一层到达下一层的最优路径,之后再往上走,他们选择的路径也就是最优路径。这里采用反向递推,让graph[i][j]存放从[i,j]位置出发到第n层所的最大值。

java 复制代码
import java.util.*;

// 数字三角形
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();

		int[][] graph = new int[n][n];

		// 5
		// 7
		// 3 8
		// 8 1 0
		// 2 7 4 4
		// 4 5 2 6 5

		for (int i = 0; i < n; i++) {
			for (int j = 0; j < i + 1; j++) {
				graph[i][j] = sc.nextInt();
			}
		}
		// 从倒数第二层开始往上计算,直到根节点
		for (int i = n - 2; i >= 0; i--) {
			for (int j = 0; j < i + 1; j++) {
				// 左斜路径
				int left = graph[i + 1][j];
				// 右斜路径
				int right = graph[i + 1][j + 1];
				// 选择左右两条路线中的最大值,并累加起来
				// 这样当前这个点存储的就是其能到达的最大值
				if (left > right) {
					graph[i][j] += left;
				} else {
					graph[i][j] += right;
				}

			}
		}
		System.out.print(graph[0][0]);

	}
}

编程14 【真题练习】数的划分

题目描述

将整数 n{n} 分成 k{k} 份,且每份不能为空,任意两份不能相同(不考虑顺序)。

例如:n=7{n=7},k=3{k=3},下面三种分法被认为是相同的。

1{1}, 1{1}, 5{5}; 1{1}, 5{5}, 1{1}; 5{5},1{1}, 1{1};

问有多少种不同的分法。

输入描述

输入一行,2{2} 个整数 n{n},k(6≤n≤200{k(6\leq n \leq 200}, 2≤k≤6){2\leq k\leq6)}。

输出描述

输出一个整数,即不同的分法。

输入输出样例

示例1

输入

sh 复制代码
7 3

输出

sh 复制代码
4

运行限制
image.png

题解

我们利用递归去求得将 n 拆分成 m 份的方案数,定义函数 f(n,m)。

对于每个情况,我们可以将其分为两大类:

  • 选1的情况
    • 肯定有一份是 1,剩余的部分 n-1 拆分成 m-1 份,即 f(n-1,m-1);
  • 不选1的情况
    • 要确保我们接下来拆分部分不包含1,我们可以让每份去分一个1出来,之后再加回去就好,相当于我们只需去求 n-m 能拆分成 m 份的方案即可,即 f(n-m,m)。
java 复制代码
import java.util.*;

// 数的划分
public class Main {

	static int[][] dp = new int[201][201];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(); // 待计算数字
		int k = sc.nextInt(); // 划分多少份

		// 初始化dp数组
		for (int i = 0; i <= n; i++) {
			for (int j = 0; j <= k; j++) {
				dp[i][j] = -1;
			}
		}

		int res = calc(n, k);
		System.out.print(res);
	}

	/**
	 * 统计有多少种分法
	 * 
	 * @param n 待划分数字
	 * @param k 划分多少份
	 * @return
	 */
	private static int calc(int n, int k) {
		// n=0,表示没有待分的数了
		// k=0,表示已经没有必要再分了,之前数字已经按k分完了
		// 比如待分的数字是16,要分17份,那么是分不了的
		if (n == 0 || k == 0 || n < k) {
			return 0;
		}
		// 假如要分的数字是16,需要分16份,那么每个分的数字只能是1
		if (n == 1 || n == k) {
			return 1;
		}
		// 避免重复计算
		if (dp[n][k] != -1) {
			return dp[n][k];
		}
		// 1. 选择包含1的路,无论划分多少份,有一份必有一个1
		// calc(n - 1, k - 1):相当于当前 n 有部分划分情况是1加起来的,
		// 2. 选择不包含1的路
		// 先让每一份都减去一个1,之后再加回来即可
		// 比如 calc(7-3,3):原本的7分成3份,每一份都不包含1
		// 变成了去求 4化成3份后的结果,最后的结果是1 2 1,那每一份都加回1,则变成 2 3 2
		dp[n][k] = calc(n - 1, k - 1) + calc(n - k, k);
		return dp[n][k];
	}
}

编程15 【真题练习】数的计算

题目描述

输入一个自然数n( ≤ 1000),我们对此自然数按照如下方法进行处理:

  1. 不作任何处理;
  2. 在它的左边加上一个自然数,但该自然数不能超过原数的一半;
  3. 加上数后,继续按此规则进行处理,直到不能再加自然数为止。

问总共可以产生多少个数。

输入描述

输入一个正整数n。

输出描述

输出一个整数,表示答案。

输入输出样例

示例1

输入

sh 复制代码
6

输出

sh 复制代码
6

运行限制
image.png

题解

java 复制代码
import java.util.*;

// 数的计算
public class Main {

	static int n;
	static int[] f; // 存放每个数字满足条件的数量

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		f = new int[n + 1];
		calc();
		System.out.println(f[n]);
		// calc1(n);
		// System.out.println(res);
	}

	static int res = 1; // 默认为自己本身

	private static void calc1(int s) {
		if (s == 1) {
			return;
		}
		// 加上去的数不超过原数的一半
		for (int i = 1; i <= s / 2; i++) {
			// 每次把符合的数字放在左边
			res++;
			// 去枚举刚加入的左边数字,它加入自己左边数字的情况
			calc1(i);
		}
	}

	private static void calc() {
		// 从1开始判断其这样加的数有多少
		// 之后的数,就会去查之前的数的组合情况数量,其实就是其能组合的情况数
		// 比如n=6
		// 1: 1(本身)
		// 2: 2 12 两种
		// 3: 3 13 两种
		// 4: 4 14 24 124 四种
		// 5: 5 15 25 125 四种
		// 6: 6 16 26 36 126 136 六种
		for (int i = 1; i <= n; i++) {
			// 加上去的数不超过原数的一半
			for (int j = 1; j <= i / 2; j++) {
				// 每次把符合的数字放在左边
				f[i] += f[j];
			}
			f[i] += 1; // 加自己本身
		}
	}
}

5. 搜索算法

深度优先搜索(DFS)

Depth First Search 即 DFS,意为深度优先搜索,是所有的搜索手段之一。它是从某个状态开始,不断进行状态转移,直到不能转移后,向后回退,一直到遍历完所有的状态。

基本概念

作为搜索算法的一种,DFS 主要是用于解决 NP 完全问题。但是,深度优先搜索算法的时间复杂度较高,深度优先搜索是 O(n!){O(n!)}的阶乘级算法,它的效率非常低,在数据规模变大时,此算法就难以解决当前的问题了。

所以搜索算法适用于状态节点较小规模的问题。

设计步骤

按照定义设计:

  1. 确定该题目的状态(包括边界)
  2. 找到状态转移方式
  3. 找到问题的出口,计数或者某个状态
  4. 设计搜索

伪代码

c++ 复制代码
int check(参数)
{
    if(满足条件)
        return 1;
    return 0;
}
bool pd(参数){
    相应操作
}
void dfs(int step)
{
        判断边界pd()
        {
            不在边界内,即回溯
        }
        尝试每一种可能
        {
               满足check条件

               标记

               继续下一步dfs(step+1)

               恢复初始状态(回溯的时候要用到)
        }
}

广度优先搜索(BFS)

BFS,其英文全称是 Breadth First Search,意为广度优先搜索,是所有的搜索手段之一。它是从某个状态开始,将所有节点加入一个先进先出的队列,然后一层一层进行状态转移,并且展开节点。

基本概念

作为搜索算法的一种,BFS 相较于 DFS 而言,BFS 是一层一层展开的,那么对于有多个终态时,最先找到的一定是最短的。

设计步骤

按照定义设计:

  1. 确定该题目的状态(包括边界)
  2. 找到状态转移方式
  3. 找到问题的出口,计数或者某个状态
  4. 设计搜索

会发现我们前期要找到的参数基本一致,所以在一般情况下 BFS 和 DFS 可以相互转换。

伪代码

c++ 复制代码
int check(参数)
{
    if(满足条件)
        return 1;
    return 0;
}
bool pd(参数){
    相应操作
}
void bfs()
{
    1. 把根节点放入队列尾端
    2. 每次从队列中取出一个节点
    3. Check 判断是不是答案,如果是结束算法 return;
    4. 把当前取出的节点扩展,如果扩展后的节点经Pd()后符合要求,就放入队列,不符合就不放。
    5. 转到步骤2,循环执行
}

如果所有节点被扩展完了,没有找到答案就无解。

编程16 N皇后问题

题目描述

在 N×N{N \times N} 的方格棋盘放置了 N{N} 个皇后,使得它们不相互攻击(即任意 2{2} 个皇后不允许处在同一排,同一列,也不允许处在与棋盘边框成 45{45} 角的斜线上。你的任务是,对于给定的 N{N},求出有多少种合法的放置方法。

输入描述

输入中有一个正整数 N≤10{N\leq10},表示棋盘和皇后的数量

输出描述

为一个正整数,表示对应输入行的皇后的不同放置数量。

输入输出样例

示例1

输入

sh 复制代码
5

输出

sh 复制代码
10

运行限制
image.png

题解

这题挺经典的算法题,下边是我一开始的写法。算是暴力搜索。

java 复制代码
import java.util.*;

// n皇后问题
public class Main {

	static boolean[][] graph; // 记录棋局中皇后的位置
	static int n; // 棋盘行列
	static int res; // 满足条件的布局数

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		graph = new boolean[n][n];
		// 遍历第一行出发的所有情况,往下搜索其余情况,看看能否在下一行放皇后
		for (int i = 0; i < n; i++) {
			graph[0][i] = true;

			dfs(1); // 进入下一行

			graph[0][i] = false;
		}
		System.out.print(res);
	}

	/**
	 * 深度搜索
	 * 
	 * @param row 第几行
	 */
	private static void dfs(int row) {
		// 最后一行也放置了皇后,说明可以
		if (row == n) {
			res++;
			return;
		}
		for (int col = 0; col < n; col++) {
			// 检验是否可以放置皇后
			if (!check(row, col))
				continue;
			graph[row][col] = true;

			dfs(row + 1); // 进入下一行

			graph[row][col] = false;
		}
	}

	/**
	 * 校验当前位置是否可以放皇后
	 * 
	 * @param row 行
	 * @param col 列
	 * @return
	 */
	private static boolean check(int row, int col) {
		// 判断同一列是否有皇后
		for (int x1 = row - 1; x1 >= 0; x1--) {
			if (graph[x1][col]) {
				return false;
			}
		}
		// 判断当前行的上面几行,这一列的左右斜线上是否有皇后
		// 45度,右斜线
		for (int x1 = row - 1, y1 = col - 1; x1 >= 0 && y1 >= 0; x1--, y1--) {
			if (graph[x1][y1]) {
				return false;
			}
		}
		// 检查135度 左斜线
		for (int x1 = row - 1, y1 = col + 1; x1 >= 0 && y1 < n; x1--, y1++) {
			if (graph[x1][y1]) {
				return false;
			}
		}
		return true;
	}
}

image.png
运行时间还不错,题目的测试用例的值不高,但如果n过大,里面多层循环判断就会很慢,于是对代码做了优化,像列我们可以直接存储哪些列已经放置皇后,做下标记,而左右斜线上是否存在皇后,可以用下面的方式做判断:

  • 左斜线:也就是135度斜线,这条线上的横纵坐标相加其实是相等的。如下图:(3+1)、(2+2)、(1+3);
  • 右斜线:也就是45度斜线,这条斜线上的横纵坐标之差是相等的,如下图:(3-2)、(2-1)、(1-0)。
image.png
java 复制代码
import java.util.*;

// n皇后问题
public class Main {

	static boolean[][] graph; // 记录棋局中皇后的位置
	static int n; // 棋盘行列
	static int res; // 满足条件的布局数
	static boolean[] cols; // 用来存放当前列是否已有皇后
	static Set<Integer> pie, na; // 用于判断135度斜线、与45度斜线是否有存放皇后

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		graph = new boolean[n][n];
		cols = new boolean[n];
		pie = new HashSet<>(); // 左斜线
		na = new HashSet<>(); // 右斜线
		// 遍历第一行出发的所有情况,往下搜索其余情况,看看能否在下一行放皇后
		for (int i = 0; i < n; i++) {
			graph[0][i] = true;
			cols[i] = true;
			na.add(0 - i); // 45度斜边的横纵坐标相减的值都相等
			pie.add(0 + i); // 135度斜边的横纵坐标相加的值都相等

			dfs(1); // 进入下一行

			graph[0][i] = false;
			cols[i] = false;
			na.remove(0 - i);
			pie.remove(0 + i);
		}
		System.out.print(res);
	}

	/**
	 * 深度搜索
	 * 
	 * @param row 第几行
	 */
	private static void dfs(int row) {
		// 最后一行也放置了皇后,说明可以
		if (row == n) {
			res++;
			return;
		}
		for (int col = 0; col < n; col++) {
			// 检验是否可以放置皇后
			if (!check(row, col))
				continue;
			graph[row][col] = true;
			cols[col] = true;
			na.add(row - col); // 45度斜边的横纵坐标相减的值都相等
			pie.add(row + col); // 135度斜边的横纵坐标相加的值都相等

			dfs(row + 1); // 进入下一行

			graph[row][col] = false;
			cols[col] = false;
			na.remove(row - col);
			pie.remove(row + col);
		}
	}

	/**
	 * 校验当前位置是否可以放皇后
	 * 
	 * @param row 行
	 * @param col 列
	 * @return
	 */
	private static boolean check(int row, int col) {
		if (cols[col] || na.contains(row - col) || pie.contains(row + col)) {
			return false;
		}
		return true;
	}
}

结果发现用时比一开始没优化的时候还长,说明这个方法适合数据量大的情况,毕竟有频繁的增删操作,会耗时。
image.png
如果只对判断同列判断这块做优化,会快一些。

java 复制代码
import java.util.*;

// n皇后问题
public class Main {

	static boolean[][] graph; // 记录棋局中皇后的位置
	static int n; // 棋盘行列
	static int res; // 满足条件的布局数
	static boolean[] cols; // 用来存放当前列是否已有皇后

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		graph = new boolean[n][n];
		cols = new boolean[n];
		// 遍历第一行出发的所有情况,往下搜索其余情况,看看能否在下一行放皇后
		for (int i = 0; i < n; i++) {
			graph[0][i] = true;
			cols[i] = true;

			dfs(1); // 进入下一行

			graph[0][i] = false;
			cols[i] = false;
		}
		System.out.print(res);
	}

	/**
	 * 深度搜索
	 * 
	 * @param row 第几行
	 */
	private static void dfs(int row) {
		// 最后一行也放置了皇后,说明可以
		if (row == n) {
			res++;
			return;
		}
		for (int col = 0; col < n; col++) {
			// 检验是否可以放置皇后
			if (!check(row, col))
				continue;
			graph[row][col] = true;
			cols[col] = true;

			dfs(row + 1); // 进入下一行

			graph[row][col] = false;
			cols[col] = false;
		}
	}

	/**
	 * 校验当前位置是否可以放皇后
	 * 
	 * @param row 行
	 * @param col 列
	 * @return
	 */
	private static boolean check(int row, int col) {
		// 判断同一列是否有皇后
    		if (cols[col]) {
			return false;
		}
    // 判断当前行的上面几行,这一列的左右斜线上是否有皇后
		// 45度,右斜线
		for (int x1 = row - 1, y1 = col - 1; x1 >= 0 && y1 >= 0; x1--, y1--) {
			if (graph[x1][y1]) {
				return false;
			}
		}
		// 检查135度 左斜线
		for (int x1 = row - 1, y1 = col + 1; x1 >= 0 && y1 < n; x1--, y1++) {
			if (graph[x1][y1]) {
				return false;
			}
		}
		return true;
	}
}
image.png

编程17 路径之谜

题目描述

小明冒充 X{X} 星球的骑士,进入了一个奇怪的城堡。

城堡里边什么都没有,只有方形石头铺成的地面。

假设城堡地面是 n×n{n\times n}个方格。如下图所示。

image.png

按习俗,骑士要从西北角走到东南角。可以横向或纵向移动,但不能斜着走,也不能跳跃。每走到一个新方格,就要向正北方和正西方各射一箭。(城堡的西墙和北墙内各有 n{n} 个靶子)同一个方格只允许经过一次。但不必走完所有的方格。如果只给出靶子上箭的数目,你能推断出骑士的行走路线吗?有时是可以的,比如上图中的例子。

本题的要求就是已知箭靶数字,求骑士的行走路径(测试数据保证路径唯一)

输入描述

第一行一个整数 N(0≤N≤20){N(0\leq N\leq20)},表示地面有N×N{N\times N}个方格。

第二行 N{N} 个整数,空格分开,表示北边的箭靶上的数字(自西向东)

第三行 N{N} 个整数,空格分开,表示西边的箭靶上的数字(自北向南)

输出描述

输出一行若干个整数,表示骑士路径。

为了方便表示,我们约定每个小格子用一个数字代表,从西北角开始编号:0,1,2,3···

比如, 上图中的方块编号为:

0 1 2 3

4 5 6 7

8 9 10 11

12 13 14 15

输入输出样例

示例

输入

sh 复制代码
4
2 4 3 4
4 3 3 3

输出

sh 复制代码
0 4 5 1 2 3 7 11 10 9 13 14 15

运行限制
image.png

题解

这题的话可以用深度搜索加回溯来做,其实还是比较好理解的,但需要注意一些条件。

  • 每走一个格子之前,需判断当前走的格子是否已经访问过,是否超出上下左右边界,当前行和列的箭是否用完;
  • 每次访问一个格子时,做相应的判断后,标记其被访问过,且将当前相应行列的箭做出扣减,且记录当前第几趟访问的格子横纵坐标,之后搜索这个格子接下来可以走的路径,结束后,恢复之前的状态,也就是回溯;
  • 每次访问一个格子时,判断当前格子是否是终点,是的话,得看看每行每列的箭是否已经射完,射完的话,则这是条合法的路径,得按当前到达终点的路径所访问的格子顺序输出,所以还得有数组来专门记录第几趟访问的格子横纵坐标。

明白上面的思路后,其实做题也就简单很多了。

java 复制代码
import java.util.*;

// 路径之谜
public class Main {
	static final int N = 30; // 数据的n范围是20
	static int[] col = new int[N]; // 每一列的射箭数
	static int[] row = new int[N];; // 每一行的射箭数
	static boolean[][] vistied = new boolean[N][N];; // 标记是否走过
	static int n; // 格子数 1到n

	// 用于之后对访问格子的顺序进行输出
	// 数据n的范围是20,意味着最多需要存储400个格子
	static int[] resX = new int[401]; // 记录第几次走的横坐标
	static int[] resY = new int[401]; // 记录第几次走的格子的纵坐标
	static int resCount = 0; // 记录已走完的格子数,从0开始记录

//---------图的路径搜索常用方向移动表示-------
	// 下,右,左,上
	static int dx[] = { 0, 1, -1, 0 };
	static int dy[] = { 1, 0, 0, -1 };

	// 两两组合形成上下左右四个方向
//  1------------------> x
//  |
//  |
//  |
//  |
//  |
//  |
//  |
//  ↓
//  y

	// dx[0]=0 dy[0]=1 那么代表向下的方向
	// dx[1]=1 dy[1]=0 那么代表向右的方向
	// dx[2]=-1 dy[0]=0 那么代表向左的方向
	// dx[3]=0 dy[1]=-1 那么代表向上的方向

	/**
	 * 校验边界
	 * 
	 * @return
	 */
	private static boolean pd(int x, int y) {
		// 该点已经访问过
		if (vistied[x][y]) {
			return false;
		}
		// 走出了左边界
		if (x < 1) {
			return false;
		}
		// 走出了右边界
		if (x > n) {
			return false;
		}
		// 走出了上边界
		if (y < 1) {
			return false;
		}
		// 走出了下边界
		if (y > n) {
			return false;
		}
		// 当前这一列的箭已经用完了
		if (col[x] <= 0) {
			return false;
		}
		// 当前这一行的箭已经用完了
		if (row[y] <= 0) {
			return false;
		}
		return true;
	}

	/**
	 * 判断是否到达终点
	 * 
	 * @param x 横坐标
	 * @param y 纵坐标
	 * @return
	 */
	private static boolean check(int x, int y) {
		if (x == n && y == n) {
			// 检查列的靶数有没有没射完的
			for (int i = 1; i <= n; i++) {
				if (col[i] != 0) {
					return false;
				}
			}
			// 检查行的靶数有没有没射完的
			for (int i = 1; i <= n; i++) {
				if (row[i] != 0) {
					return false;
				}
			}
			// 输出结果
			for (int i = 0; i < resCount; i++) {
				int rx = resX[i]; // 当前顺序的横坐标
				int ry = resY[i]; // 当前顺序的纵坐标
				// 编号是从0开始的,之前记录的坐标是从(1,1)开始的,得恢复成(0,0)开始
				int num = n * (rx - 1) + (ry - 1);
				System.out.print(num);
				if (resCount - 1 != i) {
					System.out.print(" ");
				}
			}
			System.out.println();
		}
		return true;
	}

	/**
	 * 深度搜索
	 * 
	 * @param x
	 * @param y
	 */
	private static void dfs(int x, int y) {
		// 判断是否到达终点
		if (!check(x, y)) {
			return;
		} else {
			// 尝试 下、右、左、上 四个方向
			for (int i = 0; i < 4; i++) {
				int xt = x + dx[i];
				int yt = y + dy[i];
				// 判断当前路径是否合法
				if (!pd(xt, yt))
					continue;
				// 标记该点已经访问过
				vistied[xt][yt] = true;
				col[xt]--; // 在北方射出一箭
				row[yt]--; // 在西方射出一箭
				resX[resCount] = xt;
				resY[resCount] = yt;
				resCount++;
				dfs(xt, yt);
				// 上面搜索完后,进行回溯,恢复之前的状态
				vistied[xt][yt] = false;
				col[xt]++;
				row[yt]++;
				resCount--;
			}
		}
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		for (int i = 1; i <= n; i++) {
			row[i] = sc.nextInt();
		}
		for (int i = 1; i <= n; i++) {
			col[i] = sc.nextInt();
		}
		vistied[1][1] = true; // 起点标记已访问,这里从1开始,方便之后处理边界问题
		col[1]--; // 起点的时候已经在北方射出一箭
		row[1]--; // 起点的时候已经在西方射出一箭
		resX[resCount] = 1;
		resY[resCount] = 1;
		resCount++;
		dfs(1, 1);
	}
}

编程18 最大数字

问题描述
给定一个正整数 N{N}。你可以对 N{N} 的任意一位数字执行任意次以下 2 种操作:

  1. 将该位数字加 1。如果该位数字已经是 9,加 1 之后变成 0。
  2. 将该位数字减 1。如果该位数字已经是 0,减 1 之后变成 9。

你现在总共可以执行 1 号操作不超过 A{A} 次,2 号操作不超过 B{B} 次。请问你最大可以将 N{N} 变成多少?

输入格式

第一行包含 3 个整数:N,A,B{N,A,B}。

输出格式

一个整数代表答案。

样例输入

sh 复制代码
123 1 2

样例输出

sh 复制代码
933

样例说明

对百位数字执行 2 次 2 号操作,对十位数字执行 1 次 1 号操作。

评测用例规模与约定

对于 30%{30\%} 的数据,1≤N≤100{1\leq N \leq 100}; 0≤A,B≤10{0 \leq A, B\leq 10}。
对于 100%{100\%} 的数据,1≤N≤1017{1\leq N\leq10^{17}}; 0≤A,B≤100{0\leq A, B \leq 100}

运行限制

image.png

题解

这是我一开始的代码。。。只跑通了一个样例,本地测了几种情况,都正确,后面才注意到,说的三个整数是指N、A、B,看成了N是三位数。。。

java 复制代码
import java.io.*;

// 最大数字
public class Main {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

	static long max = 0; // 记录最大值
	static int[] nums = new int[3]; // 存储当前变化的数字
	static int n;
	static String num;
	static int a, b, len;

	/**
	 * 找出每一位的最大值
	 * 
	 * @param x   要处理第几位
	 */
	private static void dfs(int x) {
		if (x == len) {
			int cur = nums[0] * 100 + nums[1] * 10 + nums[2];
			if (cur > max) {
				max = cur;
			}
			return;
		}
		// 当前要处理的位数
		int cur = nums[x];
		// 考虑第一种使用
		// 1. 可能a无法使当前这一位的数字加到9
		// 2. 可以加到9
		if (a > 0) {
			// 要么a的次数足以加到9,不行的话,也把剩余的全部用上,更高位的数字更大能保证数字最大
			int ans = Math.min(a, 9 - cur); // a所消耗的次数
			a -= ans;
			nums[x] += ans;
			dfs(x + 1);
			a += ans;
			nums[x] -= ans;
		}
		// 考虑第二种使用
		if (b > 0) {
			// 如果剩余的b,能让这个当前这位的值小于0
			// 那么就使用它,否则就不用它了,越减越小
			if (cur - b < 0) {
				int ans = cur + 1; // b所消耗的次数
				b -= ans;
				nums[x] = 9;
				dfs(x + 1);
				nums[x] = cur;
				b += ans;
			}
		}
		// 都不考虑
		dfs(x + 1);
	}

	public static void main(String[] args) throws IOException {
		String[] arr = br.readLine().split(" ");
		num = arr[0];
		a = Integer.parseInt(arr[1]);
		b = Integer.parseInt(arr[2]);

		len = num.length();
		if (num.length() == 1) {
			nums[2] = n;
		} else if (num.length() == 2) {
			nums[1] = Integer.parseInt(num.charAt(0) + "");
			nums[2] = Integer.parseInt(num.charAt(1) + "");
		} else {
			nums[0] = Integer.parseInt(num.charAt(0) + "");
			nums[1] = Integer.parseInt(num.charAt(1) + "");
			nums[2] = Integer.parseInt(num.charAt(2) + "");
		}
		dfs(0);
		out.print(max);
		out.flush();
	}
}

那就不太好用数组来存储了,毕竟数组占用内存还是挺大的,我们直接计算每一位时,找出其最大可能的值后,将结果与上一次的结果扩大十倍后,进行相加,传递给下一位,直到处理到最后一位时,进行比较结果,记录最大值即可。

java 复制代码
import java.io.*;

// 最大数字
public class Main {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

	static long max = 0; // 记录最大值
	static String num;
	static int a, b, len;

	/**
	 * 找出每一位的最大值
	 * 
	 * @param x   要处理第几位
	 * @param val 当前的值
	 */
	private static void dfs(int x, long val) {
		// 最后一位已经处理了,判断是否超过之前的最大值
		if (x == len) {
			max = Math.max(max, val);
			return;
		}
		// 当前要处理的位数
		int cur = num.charAt(x) - '0'; // 这样算出当前位的值
		// 考虑第一种使用
		// 1. 可能a无法使当前这一位的数字加到9
		// 2. 可以加到9
		// 要么a的次数足以加到9,不行的话,也把剩余的全部用上,更高位的数字更大能保证数字最大
		int ans = Math.min(a, 9 - cur); // a所消耗的次数
		a -= ans;
		dfs(x + 1, val * 10 + cur + ans);
		a += ans;
		// 考虑第二种使用
		if (b > 0) {
			// 如果剩余的b,能让这个当前这位的值小于0,说明能让这位数的值为9
			// 那么就使用它,否则就不用它了,越减越小
			if (cur - b < 0) {
				ans = cur + 1; // b所消耗的次数
				b -= ans;
				dfs(x + 1, val * 10 + 9);
				b += ans;
			}
		}
	}

	public static void main(String[] args) throws IOException {
		String[] arr = br.readLine().split(" ");
		num = arr[0];
		a = Integer.parseInt(arr[1]);
		b = Integer.parseInt(arr[2]);

		len = num.length();
		dfs(0, 0);
		out.print(max);
		out.flush();
	}

}
image.png

编程19 长草

题目描述

小明有一块空地,他将这块空地划分为 n{n} 行 m{m} 列的小块,每行和每列的长度都为 1。

小明选了其中的一些小块空地,种上了草,其他小块仍然保持是空地。

这些草长得很快,每个月,草都会向外长出一些,如果一个小块种了草,则它将向自己的上、下、左、右四小块空地扩展,

这四小块空地都将变为有草的小块。请告诉小明,k{k} 个月后空地上哪些地方有草。

输入描述
输入的第一行包含两个整数 n,m{n,m}。

接下来 n{n} 行,每行包含 m{m} 个字母,表示初始的空地状态,字母之间没有空格。如果为小数点,表示为空地,如果字母为 g{g},表示种了草。

接下来包含一个整数 k{k}。其中,2≤n,m≤1000,1≤k≤1000{2\leq n,m \leq 1000, 1\leq k\leq 1000}。

输出描述

输出 n{n} 行,每行包含 m{m} 个字母,表示 k{k} 个月后空地的状态。如果为小数点,表示为空地,如果字母为 g{g},表示长了草。

输入输出样例

示例

输入

sh 复制代码
4 5
.g...
.....
..g..
.....
2

输出

sh 复制代码
gggg.
gggg.
ggggg
.ggg.

运行限制

image.png

题解

这题还是很简单的,有点像走迷宫,往四个方向判断是否可以种草,可以的话,就标记即可,注意区分下是否是上个月的草和这个月的草,这个月种的草得下个月才能长。故我这里用了个数组vistied来标记这个月种的草,避免与上个月混淆。

这里的话我用了 DFS 来做题。

java 复制代码
import java.io.*;

// 长草
public class Main {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static final int N = 1010;
	static String[][] graph = new String[N][N]; // 存储每行每列的草状态
	static boolean[][] vistied = new boolean[N][N]; // 标记这一次新种的草
	static int n, m, k;
	// 上,左,右,下
	static int[] DX = { 0, -1, 1, 0 }; // 横坐标
	static int[] DY = { -1, 0, 0, 1 }; // 纵坐标
//	4 5
//	.g...
//	.....
//	..g..
//	.....
//	2

//	gggg.
//	gggg.
//	ggggg
//	.ggg.

	/**
	 * 处理每个月长草
	 * 
	 * @param month 第几月
	 */
	private static void dfs(int month) {
		if (month == k) {
			for (int i = 1; i <= n; i++) {
				for (int j = 1; j <= m; j++) {
					System.out.print(graph[i][j]);
				}
				System.out.println();
			}
			return;
		}
		// 存储上个月的分布
		vistied = new boolean[N][N];
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				// 当前位置是草,且不是刚种的
				if (!vistied[i][j] && "g".equals(graph[i][j])) {
					for (int x = 0; x < 4; x++) {
						// 要种草的方位
						int dy = i + DX[x];
						int dx = j + DY[x];
						// 判断当前位置是否是空地
						if (!check(dx, dy))
							continue;
						// 上个月这里是空地,那就可以种
						// 上个月这里是空地,那就可以种
						if (".".equals(graph[dy][dx])) {
							graph[dy][dx] = "g";
							vistied[dy][dx] = true;
						}

					}
				}
			}
		}
		dfs(month + 1);
	}

	/**
	 * 校验当前要种的位置是否在场地内
	 * 
	 * @param x 横坐标
	 * @param y 纵坐标
	 * @return
	 */
	private static boolean check(int x, int y) {
		if (x < 1 || x > m || y < 1 || y > n)
			return false;
		return true;
	}

	public static void main(String[] args) throws IOException {
		String[] arr = br.readLine().split(" ");
		n = Integer.parseInt(arr[0]);
		m = Integer.parseInt(arr[1]);
		for (int i = 1; i <= n; i++) {
			String str = br.readLine();
			for (int j = 1; j <= m; j++) {
				graph[i][j] = str.charAt(j - 1) + "";
			}
		}
		k = Integer.parseInt(br.readLine());
		dfs(0);
	}
}

image.png
时间有些不稳定,偶尔会超时,我这里重新优化了下,因为输出的数据挺大的,我们可以用流来输出会快些,同时不要一个一个打印,会很慢,先将结果拼接起来,然后再一次性输出,会快很多。

java 复制代码
import java.io.*;

// 长草
public class Main {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
	static final int N = 1010;
	static String[][] graph = new String[N][N]; // 存储每行每列的草状态
	static boolean[][] vistied = new boolean[N][N]; // 标记这一月新种的草
	static int n, m, k;
	// 上,左,右,下
	static int[] DX = { 0, -1, 1, 0 }; // 横坐标
	static int[] DY = { -1, 0, 0, 1 }; // 纵坐标
//	4 5
//	.g...
//	.....
//	..g..
//	.....
//	2

//	gggg.
//	gggg.
//	ggggg
//	.ggg.

	/**
	 * 处理每个月长草
	 * 
	 * @param month 第几月
	 */
	private static void dfs(int month) {
		if (month == k) {
			StringBuilder sb = new StringBuilder();
			for (int i = 1; i <= n; i++) {
				for (int j = 1; j <= m; j++) {
					sb.append(graph[i][j]);
				}
				sb.append("\n");
			}
			pw.println(sb);
			return;
		}
		vistied = new boolean[N][N]; // 用于标记这个月新种的草
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				// 当前位置是草,且不是刚种的
				if (!vistied[i][j] && "g".equals(graph[i][j])) {
					for (int x = 0; x < 4; x++) {
						// 要种草的方位
						int dy = i + DX[x];
						int dx = j + DY[x];
						// 判断当前位置是否是空地
						if (!check(dx, dy))
							continue;
						// 上个月这里是空地,那就可以种
						if (".".equals(graph[dy][dx])) {
							graph[dy][dx] = "g";
							vistied[dy][dx] = true;
						}

					}
				}
			}
		}
		dfs(month + 1);
	}

	/**
	 * 校验当前要种的位置是否在场地内
	 * 
	 * @param x 横坐标
	 * @param y 纵坐标
	 * @return
	 */
	private static boolean check(int x, int y) {
		if (x < 1 || x > m || y < 1 || y > n)
			return false;
		return true;
	}

	public static void main(String[] args) throws IOException {
		String[] arr = br.readLine().split(" ");
		n = Integer.parseInt(arr[0]);
		m = Integer.parseInt(arr[1]);
		for (int i = 1; i <= n; i++) {
			String str = br.readLine();
			for (int j = 1; j <= m; j++) {
				graph[i][j] = str.charAt(j - 1) + "";
			}
		}
		k = Integer.parseInt(br.readLine());
		dfs(0);
		pw.flush();
		pw.close();
	}
}
image.png

换成 BFS 来做题,思路还是大致一直的,将需要判断的格子位置放入队列,之后每次从队列取出来,判断可以走的路径,然后将可以走的格子重新放入队列。

java 复制代码
import java.util.*;
import java.util.concurrent.LinkedBlockingQueue;
import static java.lang.Math.abs;

public class Main {

    static final int M = 1005;
    static class PII
    {
        public int first;
        public int second;
    };

    static String Map[]=new String[M];
//---------图的路径搜索常用方向移动表示-------
    static int dx[]= {0,1,-1,0};
    static  int dy[]= {1,0,0,-1};

// 两两组合形成上下左右四个方向
//      1------------------> x
//      |
//      |
//      |
//      |
//      |
//      |
//      |
//      ↓
//      y

// dx[0]=0 dy[0]=1 那么代表向下的方向
// dx[1]=1 dy[1]=0 那么代表向右的方向
// dx[2]=-1 dy[0]=0 那么代表向左的方向
// dx[3]=0 dy[1]=-1 那么代表向上的方向

    static int n;// n 行
    static int m;// m 列
    static int k;// k 次

    static Queue<PII > q= new LinkedBlockingQueue<>();
    //广度优先搜索所用的队列

    static int len;//记录节点数量方便后续k的计算
    static boolean pd(int x, int y)
    {

        if(x<1)
            return false;
            // /x 轴坐标 左侧越界
        else if(x>n)
            return false;
            //x 轴坐标 右侧越界
        else  if(y<1)
            return false;
            //y 轴坐标 上侧越界
        else if(y>m)
            return false;
            //y 轴坐标 下侧越界
        else if(Map[x].charAt(y)=='g')
            return false;
            //已经长草了
        else return true;
        // 在范围内,且没长草
    }

    static void BFS()
    {
        //BFS
        while(q.size()!=0&&k>0)
        {
            PII tempPair= q.peek();
            q.poll();
            //这两步是取出队首的节点
//            System.out.println(q.size());
            int x = tempPair.first;//横坐标
            int y = tempPair.second;//纵坐标
            for(int i=0; i<4; i++)
            {
                int nowx = x+dx[i]; //扩展后的横坐标
                int nowy = y+dy[i]; //扩展后的纵坐标
                if(pd(nowx,nowy))
                {
                    PII tempPair2=new PII();//临时结点
                    tempPair2.first=nowx;
                    tempPair2.second=nowy;
                    q.add(tempPair2);
                    StringBuilder strBuilder = new StringBuilder(Map[nowx]);
                    strBuilder.setCharAt(nowy, 'g');
                    Map[nowx]=strBuilder.toString();
                }
                //符合要求执行扩展,不符合要求,忽略即可。
            }
            len--; //没取出一个节点len  -1
            if(len==0)
            {
                //当len =0 时,代表当前层扩展完了,那么就代表第一个月扩展完了
                k--; // 所以k--
                len = q.size(); // 当前层扩展完了,那就该扩展下一层了,所以len又被赋值为下一层的节点数目的值
            }
        }
    }

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        for(int i=1; i<=n; i++)
        {
            Map[i]=new String(" " +in.next());
            for(int j=1; j<=m; j++)
            {
                char temChar = Map[i].charAt(j);
                if(temChar=='g')
                {
                    PII tempPair=new PII();//临时结点
                    tempPair.first=i;
                    tempPair.second=j;
                    q.offer(tempPair);//将初始有草的结点加入队列
                }
            }
        }

        len = q.size();//记录第一层的节点数量方便后续k的计算
        k= in.nextInt();
        BFS();
        for(int i=1; i<=n; i++)
        {
            System.out.println(Map[i]);
        }

    }
}

编程20 走迷宫

题目描述

给定一个 N×M{N\times M} 的网格迷宫 G{G}。 G{G} 的每个格子要么是道路,要么是障碍物(道路用 1{1} 表示,障碍物用 0{0} 表示)。

已知迷宫的入口位置为 (x1,y1){(x_1,y_1)},出口位置为 (x2,y2){(x_2,y_2)} 。问从入口走到出口,最少要走多少个格子。

输入描述

输入第 1{1} 行包含两个正整数 N,M{N,M},分别表示迷宫的大小。

接下来输入一个 N×M{N\times M} 的矩阵。若 Gi,j=1{G_{i,j}=1} 表示其为道路,否则表示其为障碍物。

最后一行输入四个整数 x1,y1,x2,y2{x_1,y_1,x_2,y_2},表示入口的位置和出口的位置。

1≤N,M≤102,0≤Gi,j≤1,1≤x1,x2≤N,1≤y1,y2≤M{1\leq N,M\leq 10^2,0\leq G_{i,j}\leq1, 1\leq x_1,x_2\leq N,1\leq y_1,y_2 \leq M}。

输出描述

输出仅一行,包含一个整数表示答案。

若无法从入口到出口,则输出 −1{-1}。

输入输出样例

示例1

输入

sh 复制代码
5 5 
1 0 1 1 0
1 1 0 1 1 
0 1 0 1 1
1 1 1 1 1
1 0 0 0 1
1 1 5 5 

输出

sh 复制代码
8

运行限制
image.png

题解

一开始想着用 DFS 直接做题,但发现只有两个样例通过了。

java 复制代码
import java.io.*;

// 走迷宫
public class Main {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
	// 上,右,左,下
	static int[] DY = { 0, 1, -1, 0 };
	static int[] DX = { -1, 0, 0, 1 };

	static int N = 110;
	static int n, m;
	static int[][] graph = new int[N][N]; // 存储迷宫
	static boolean[][] vistied = new boolean[N][N]; // 存储哪些路已经走过
	static int minRes = Integer.MAX_VALUE; // 存储最短路径的格子数

	// 入口位置,出口位置
	static int x1, y1, x2, y2;

	/**
	 * 搜索路径
	 * 
	 * @param curX  行
	 * @param curY  列
	 * @param count
	 */
	private static void dfs(int curX, int curY, int count) {
		// 走的格子都已经超出迷宫的格子了,说明无路可走
		// if (count >= n * m - 2) {
		// 	return;
		// }
		// 到达终点
		if (curX == x2 && curY == y2) {
			minRes = Math.min(minRes, count);
			return;
		}
		// 遍历四个方向
		for (int i = 0; i < 4; i++) {
			int dx = curX + DX[i]; // 行
			int dy = curY + DY[i]; // 列
			if (!check(dx, dy))
				continue;
			vistied[dx][dy] = true;
			dfs(dx, dy, count + 1);
			vistied[dx][dy] = false;
		}
	}

	/**
	 * 判断是否达到边界,或者无路可走,或者该位置已经是走过的
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private static boolean check(int x, int y) {
		if (x < 1 || x > n || y < 1 || y > m || graph[x][y] == 0 || vistied[x][y])
			return false;
		return true;
	}

	public static void main(String[] args) throws IOException {
		String[] arr = br.readLine().split(" ");
		n = Integer.parseInt(arr[0]);
		m = Integer.parseInt(arr[1]);
		for (int i = 1; i <= n; i++) {
			arr = br.readLine().split(" ");
			for (int j = 1; j <= m; j++) {
				graph[i][j] = Integer.parseInt(arr[j - 1]);
			}
		}
		arr = br.readLine().split(" ");
		x1 = Integer.parseInt(arr[0]);
		y1 = Integer.parseInt(arr[1]);
		x2 = Integer.parseInt(arr[2]);
		y2 = Integer.parseInt(arr[3]);

		// 起点出发
		vistied[x1][y1] = true;
		dfs(x1, y1, 0);
		pw.println(minRes == Integer.MAX_VALUE ? -1 : minRes);
		pw.flush();
		pw.close();
	}
}

image.png
试着改为用 BFS 解题,思路也是一样的,一开始测得时候也只通过两例,后面试着换成 Scanner 来读入数据就没问题,全部样例都通过。那就说明之前在接收数据那块处理有问题,那有些有问题的话,可能就是空格切割字符串这块可能出问题了,可能有样例中间有多个空格,比较坑。。。改了后成功通过。

java 复制代码
import java.io.*;
import java.util.*;

// 走迷宫
public class Main {

	static class Node {
		int x;
		int y;

		public Node(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));

	static int N = 110;
	static int n, m, ans;
	static int[][] graph = new int[N][N]; // 存储迷宫
	static int[][] vistied = new int[N][N]; // 标记哪些路已经走过,并且存储他们的最短路径

	// 右,下,上,左
	static int[] DX = { 0, 1, -1, 0 };
	static int[] DY = { 1, 0, 0, -1 };

	// 入口位置,出口位置
	static int x1, y1, x2, y2;
	static Node start, end;

	// 搜索队列
	static Queue<Node> queue = new LinkedList<Node>();

	/**
	 * 校验是否达到终点
	 * 
	 * @param node
	 * @return
	 */
	private static boolean check(Node node) {
		if (node.x == end.x && node.y == end.y) {
			// 更新距离,广度优先搜索找到的路径一定是最短的
			ans = vistied[node.x][node.y];
			return true;
		}
		return false;
	}

	/**
	 * 当前当前这一步是否可以走
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private static boolean pd(int x, int y) {
		// 判断有没有走出边界,或者这条路是否可以走,或者是否已经走过
		if (x < 1 || x > n || y < 1 || y > m || graph[x][y] != 1 || vistied[x][y] != 0)
			return false;
		return true;
	}

	/**
	 * 广度优先搜索
	 * 
	 * @param x
	 * @param y
	 */
	private static void bfs() {
		// 将起点加入队列
		queue.add(start);
		// 标记该节点已经访问过,且当前走到这一步的格子数为1
		vistied[start.x][start.y] = 1;

		while (!queue.isEmpty()) {
			Node node = queue.peek(); // 拿到当前待处理的结点(但未取出)
			// 判断当前这一个节点是否是终点
			if (check(node)) {
				return;
			}
			queue.poll();
			// 尝试四个方向
			for (int i = 0; i < 4; i++) {
				int dx = node.x + DX[i];
				int dy = node.y + DY[i];
				// 判断这一步是否可行
				if (pd(dx, dy)) {
					Node next = new Node(dx, dy);
					// 更新走到该点的步数
					vistied[dx][dy] = vistied[node.x][node.y] + 1;
					queue.add(next);
				}
			}
		}
	}

	public static void main(String[] args) throws IOException {
		String[] arr = br.readLine().split(" ");
		n = Integer.parseInt(arr[0]);
		m = Integer.parseInt(arr[1]);
		for (int i = 1; i <= n; i++) {
			arr = br.readLine().split(" +");
			for (int j = 1; j <= m; j++) {
				graph[i][j] = Integer.parseInt(arr[j - 1]);
			}
		}
		arr = br.readLine().split(" +");

		x1 = Integer.parseInt(arr[0]);
		y1 = Integer.parseInt(arr[1]);
		x2 = Integer.parseInt(arr[2]);
		y2 = Integer.parseInt(arr[3]);
		start = new Node(x1, y1);
		end = new Node(x2, y2);
		bfs();
		// 开始结点是从1开始的,故要减去1,题目不包含起点格子
		pw.println(ans - 1);
		pw.flush();
		pw.close();
	}
}

image.png
顺便把之前用 DFS 解题的也代码也改一下,看看能不能跑通。发现没报错了,但超时了,DFS 对于数据量大的情况,深度越深,时间复杂度是指数级的!

java 复制代码
import java.io.*;

// 走迷宫
public class Main {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
	// 上,右,左,下
	static int[] DY = { 0, 1, -1, 0 };
	static int[] DX = { -1, 0, 0, 1 };

	static int N = 110;
	static int n, m;
	static int[][] graph = new int[N][N]; // 存储迷宫
	static boolean[][] vistied = new boolean[N][N]; // 存储哪些路已经走过
	static int minRes = Integer.MAX_VALUE; // 存储最短路径的格子数

	// 入口位置,出口位置
	static int x1, y1, x2, y2;

	/**
	 * 搜索路径
	 * 
	 * @param curX  行
	 * @param curY  列
	 * @param count
	 */
	private static void dfs(int curX, int curY, int count) {
		// 到达终点
		if (curX == x2 && curY == y2) {
			minRes = Math.min(minRes, count);
			return;
		}
		// 遍历四个方向
		for (int i = 0; i < 4; i++) {
			int dx = curX + DX[i]; // 行
			int dy = curY + DY[i]; // 列
			if (!check(dx, dy))
				continue;
			vistied[dx][dy] = true;
			dfs(dx, dy, count + 1);
			vistied[dx][dy] = false;
		}
	}

	/**
	 * 判断是否达到边界,或者无路可走,或者该位置已经是走过的
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private static boolean check(int x, int y) {
		if (x < 1 || x > n || y < 1 || y > m || graph[x][y] == 0 || vistied[x][y])
			return false;
		return true;
	}

	public static void main(String[] args) throws IOException {
		String[] arr = br.readLine().split(" ");
		n = Integer.parseInt(arr[0]);
		m = Integer.parseInt(arr[1]);
		for (int i = 1; i <= n; i++) {
			arr = br.readLine().split(" +");
			for (int j = 1; j <= m; j++) {
				graph[i][j] = Integer.parseInt(arr[j - 1]);
			}
		}
		arr = br.readLine().split(" +");
		x1 = Integer.parseInt(arr[0]);
		y1 = Integer.parseInt(arr[1]);
		x2 = Integer.parseInt(arr[2]);
		y2 = Integer.parseInt(arr[3]);

		// 起点出发
		vistied[x1][y1] = true;
		dfs(x1, y1, 0);
		pw.println(minRes == Integer.MAX_VALUE ? -1 : minRes);
		pw.flush();
		pw.close();
	}
}
image.png

编程21 迷宫

题目描述

本题为填空题,只需要算出结果后,在代码中使用输出语句将所填结果输出即可。

下图给出了一个迷宫的平面图,其中标记为 1{1} 的为障碍,标记为 0{0} 的为可以通行的地方。

sh 复制代码
010000
000100
001001
110000

迷宫的入口为左上角,出口为右下角,在迷宫中,只能从一个位置走到这个它的上、下、左、右四个方向之一。

对于上面的迷宫,从入口开始,可以按 DRRURRDDDR 的顺序通过迷宫,一共 10{10} 步。其中 D{D}、U{U}、L{L}、R{R} 分别表示向下、向上、向左、向右走。对于下面这个更复杂的迷宫(30{30} 行 50{50} 列),请找出一种通过迷宫的方式,其使用的步数最少,在步数最少的前提下,请找出字典序最小的一个作为答案。

请注意在字典序中D<L<R<U{D\lt L\lt R\lt U}。

sh 复制代码
01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

运行限制
image.png

题解

题目要求步数最少,那我们用 BFS 即可求出最短路径,唯一的麻烦点是需要打印这一条最短路径,那我们其实可以用来存储每次访问该点时的上一个节点的坐标,并且是根据什么操作到达这个节点的。之后访问到终点时,我们就得到了这条最短路径,我们可以从终点回溯到起点,之后从起点开始打印出来。

java 复制代码
import java.io.*;
import java.util.*;

// 迷宫
public class Main {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));

	static String[] arr = { "01010101001011001001010110010110100100001000101010",
			"00001000100000101010010000100000001001100110100101", "01111011010010001000001101001011100011000000010000",
			"01000000001010100011010000101000001010101011001011", "00011111000000101000010010100010100000101100000000",
			"11001000110101000010101100011010011010101011110111", "00011011010101001001001010000001000101001110000000",
			"10100000101000100110101010111110011000010000111010", "00111000001010100001100010000001000101001100001001",
			"11000110100001110010001001010101010101010001101000", "00010000100100000101001010101110100010101010000101",
			"11100100101001001000010000010101010100100100010100", "00000010000000101011001111010001100000101010100011",
			"10101010011100001000011000010110011110110100001000", "10101010100001101010100101000010100000111011101001",
			"10000000101100010000101100101101001011100000000100", "10101001000000010100100001000100000100011110101001",
			"00101001010101101001010100011010101101110000110101", "11001010000100001100000010100101000001000111000010",
			"00001000110000110101101000000100101001001000011101", "10100101000101000000001110110010110101101010100001",
			"00101000010000110101010000100010001001000100010101", "10100001000110010001000010101001010101011111010010",
			"00000100101000000110010100101001000001000000000010", "11010000001001110111001001000011101001011011101000",
			"00000110100010001000100000001000011101000000110011", "10101000101000100010001111100010101001010000001000",
			"10000010100101001010110000000100101010001011101000", "00111100001000010000000110111000000001000000001011",
			"10000001100111010111010001000110111010101101111000" };
//	static String[] arr = { "010000", "000100", "001001", "110000" };
//	static final int n = 30, m = 50;
	static final int n = 30, m = 50;

	static char[][] graph = new char[n][m]; // 迷宫
	static boolean[][] vistied = new boolean[n][m]; // 标记点是否已经访问过

	// 方向:D、L、R、U
	static int[][] step = { { 1, 0 }, { 0, -1 }, { 0, 1 }, { -1, 0 } };
	static char[] direction = { 'D', 'L', 'R', 'U' };

	static Node[][] father = new Node[1000][1000]; // 用来存储每次访问的结点的上一个节点坐标,用于回溯

	static Queue<Node> queue = new LinkedList<>();

	static class Node {
		int x;
		int y;
		int d; // 当前走这条路时已经走过的格子数
		char pos;

		public Node(int x, int y, int d) {
			this.x = x;
			this.y = y;
			this.d = d;
		}

	}

	/**
	 * 是否到达终点
	 * 
	 * @param x 行
	 * @param y 列
	 * @return
	 */
	private static boolean check(int x, int y) {
		if (x == n - 1 && y == m - 1) {
			return true;
		}
		return false;
	}

	/**
	 * 判断改路径是否可走
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private static boolean pd(int x, int y) {
		// 越界判断
		if (x < 0 || x > n - 1 || y < 0 || y > m - 1)
			return false;
		// 是否访问过,或者是否是障碍物
		if (graph[x][y] == '1' || vistied[x][y]) {
			return false;
		}
		return true;
	}

	/**
	 * 广度优先搜索
	 * 
	 * @param x 起点坐标
	 * @param y
	 */
	private static void bfs(int x, int y) {
		queue.add(new Node(x, y, 0)); // 添加起点
		vistied[x][y] = true;
		while (!queue.isEmpty()) {
			Node now = queue.peek();
			// 看看是否到达终点
			if (check(now.x, now.y)) {
				return;
			}
			queue.poll();
			// 看看四个方向,下左右上
			for (int i = 0; i < 4; i++) {
				int nextX = now.x + step[i][0];
				int nextY = now.y + step[i][1];
				// 判断当前这一步可以走不
				if (pd(nextX, nextY)) {
					vistied[nextX][nextY] = true; // 标记为已用过
					Node next = new Node(nextX, nextY, now.d + 1);
					queue.add(next);

					// 存储父节点,之后回溯
					father[nextX][nextY] = new Node(now.x, now.y, now.d);
					// 存储当时访问这个 next 节点时,父节点是往那个方向走的
					father[nextX][nextY].pos = direction[i];
				}
			}
		}
	}

	/**
	 * 深度优先搜索
	 * 
	 * @param x
	 * @param y
	 */
	private static void dfs(int x, int y) {
		// 找到起点,返回上一步,开始输出每一步父节点的路径
		if (x == 0 && y == 0) {
			return;
		} else {
			// 找到上一个父节点
			dfs(father[x][y].x, father[x][y].y);
		}
		System.out.print(father[x][y].pos);
	}

	public static void main(String[] args) throws IOException {
		for (int i = 0; i < n; i++) {
			graph[i] = arr[i].toCharArray();
		}
		// 找出最短路径
		bfs(0, 0);
		// 从最后一个结点回溯到根节点,然后从根节点打印逐步打印出来
		dfs(n - 1, m - 1);
	}
}

6. 差分和前缀和

差分与前缀和是一对互逆的操作,常常用于处理区间问题,差分法是解决区间加减问题,前缀和是解决区间求和问题的常用办法。

知识点

  • 差分算法
  • 前缀和算法

差分法

差分法的应用主要是用于处理区间问题。当某一个数组要在很多不确定的区间,加上相同的一个数。我们如果每个都进行加法操作的话,那么复杂度 O(nm)O(nm) 是平方阶的,非常消耗时间。

如果我们采用差分法,将数组拆分,构造出一个新的拆分数组,通过对数组区间的端点进行加减操作,最后将数组和并就能完成原来的操作。

这样处理后,时间复杂度降低为 O(N)O(N),虽然感觉操作变得更加复杂了,但是只用对边界操作确实比操作一整个区间的方法要优秀的多。

特点

  1. 将对于区间的加减操作转化为对于端点的操作;
  2. 时间复杂度为 O(n)O(n);
  3. 用于维护区间的增减但不能维护乘除;
  4. 差分后的序列比原来的数组序列多一个数。

解题基本思路

  1. 设定b[1]=a[1]b[1]=a[1];
  2. 对于第 2 项到第 n 项,利用差分式b[i]=a[i]−a[i−1]b[i]=a[i]-a[i-1];
  3. 对于区间端点进行加减操作;
  4. 进行差分还原(即前缀和);
  5. 注意,这里从 1 开始。如果从 0 开始,还需讨论 i=0i=0 的情况。使用 1 的话,b[1]=a[1]−a[0]=a[1]b[1]=a[1]-a[0]=a[1]。

前缀和

前缀和法的应用主要也是用于处理区间问题。

前缀和是指某序列的前 nn 项和,可以把它理解为数学上的数列的前 nn 项和。当对于某一数组区间进行多次询问,[l,r][l,r] 的和时,如果正常处理,那么我们每次都要 [l,r][l,r]。查询 NN 次,那么时间复杂度也是 O(nm)O(nm) 也是平方阶的。

如果我们采用前缀和,构造出一个前缀和数组,通过对于端点的值的减法操作就能 O(1)O(1) 的求出 [l,r][l,r] 的和。然后 NN 次查询的,就将复杂度降低为 O(N)O(N)。

同差分一样,感觉操作变得更加复杂了,但是只用对端点值的操作确实比一整个区间相加的方法要优秀的多。

特点:

  1. 将对于区间的求和操作转化为对于端点值的减法的操作;
  2. 区间求和操作的时间复杂度为 O(1)O(1);
  3. 数组存放时要从 11 开始;
  4. 前缀和数组比原来的数组序列多一个数,第 00 个元素为 00。

解题基本思路:

  1. 利用 sum[i]=a[i]+sum[i−1]sum[i]=a[i]+sum[i-1] 差分式;
  2. 从第 11 项到 nn 项,且第 00 项无数据默认为 00;
  3. 对于区间求和的操作转化为端点值相减。

解题过程

sh 复制代码
首先假设有一个数组:

1 2 3 4 5 7 2

前缀和后:

0 1 3 6 10 15 22 24

一般应用场景:

让你对区间 [l,r] 求和操作N次

如:

从第二个元素到第五个元素的和
从第二个元素到第四个元素的和
从第一个元素到第三个元素的和
....

这里我们先演示前三个:

对于每个 [l,r] 区间的求和操作转化为区间端点的加减操作

sum[l,r] =[r]-[l-1]

从第二个元素到第五个元素的和:

转化为:[5]-[1]

那么Sum[2,5]=[5]-[1]=14

且 2+3+4+5=14

确实是相等的,就是这么神奇。

我们继续操作:

从第二个元素到第四个元素的和

转化为:[4]-[1]

那么Sum[2,4]=[4]-[1]=9

且 2+3+4=9

我们继续操作:

从第一个元素到第三个元素的和

转化为:[3]-[0]

那么Sum[1,3]=[3]-[0]=6

且 1+2+3=6

符合题意,验证结束,咱么做个题目看一看

编程22 大学里的树木要打药

题目描述

教室外有 N{N} 棵树(树的编号从 0∼N−1{0\sim N-1}),根据不同的位置和树种,学校要对其上不同的药。

因为树的排列成线性,且非常长,我们可以将它们看作一条直线给他们编号。

对于树的药是成区间分布, 比如 3∼5{3\sim 5} 号的树靠近下水道,所以他们要用驱蚊虫的药,20∼26{20\sim26} 号的树,他们排水不好,容易涝所以要给他们用点促进根系的药⋯\cdots诸如此类。

每种不同的药要花不同的钱。

现在已知共有 M{M} 个这样的区间,并且给你每个区间花的钱,问最后这些树木要花多少药费。

输入描述

每组输入的第一行有两个整数 N{N} 和 M{M}。N{N} 代表马路的共计多少棵树,M{M} 代表区间的数目,N{N} 和 M{M} 之间用一个空格隔开。

接下来的 M{M} 行每行包含三个不同的整数,用一个空格隔开,分别表示一个区域的起始点 L{L} 和终止点 R{R} 的坐标,以及花费。

1<L≤R≤N≤106,1≤M≤105{1\lt L\leq R\leq N\leq 10^6,1\leq M\leq10^5},保证花费总和不超过 int 范围。

输出描述

输出包括一行,这一行只包含一个整数,所有的花费。

输入输出样例

示例1

输入

sh 复制代码
500 3
150 300 4
100 200 20
470 471 19

输出

sh 复制代码
2662

示例2

输入

sh 复制代码
3000 8
150 1130 2
1020 1200 3
470 2071 1
1123  211 6
12 222 2
13 23 2
1  213 4
1232  2523 6

输出

sh 复制代码
7689

运行限制
image.png

题解

这题的话其实就是算所有区间的总花费是多少,那我们已知区间范围,就能知道里面有多少颗树,那自然就可以算出费用了。

java 复制代码
import java.util.*;

// 大学里的树木要打药
public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(); // 一共有多少颗树
		int m = sc.nextInt(); // 多少个区间
		int sum = 0;
		// 500 3
		// 150 300 4
		// 100 200 20
		// 470 471 19
		// 604 + 2020 + 38 = 2662
		while (m-- > 0) {
			int st = sc.nextInt();
			int en = sc.nextInt();
			int val = sc.nextInt();
			sum += (en - st + 1) * val;
		}
		System.out.print(sum);
	}
}

我们试试差分法来解这题,在这之前,这里先举个例子,好理解下差分法。我们对区间 a[1,3]a[1,3]做 +5+5 操作,对区间 a[3,5]a[3,5]做 −5-5 操作,之后的过程如下:
image.png
image.png

步骤如下:

  1. 把区间 aa 转换成 差分区间 bb:有区间的起点ll,终点rr,a[l,r]a[l,r] 区间的值做加减法,则我们可以转换为:b[l]+=vb[l]+=v,b[r+1]−=vb[r+1]-=v,相当于区间 a[l,r]+=va[l,r]+=v。除了这些关系外,还有这点:bi=ai−ai−1b_i=a_i-a_{i-1},存储的是相邻数字间的差。
  2. 之后还原的话,我们的做拆分的话,编号是从 11 开始的,故之前的转换时,如果原本的区间是从编号 00 开始的,我们则需要使其变成从 11 开始。
  3. 接着拆分的话 a0=0a_0=0,有 ai=bi+ai−1a_i=b_i+a_{i-1},故 b1=a1−a0=a1b_1=a_1-a_0=a_1,接着循环还原出当前下标的值,如:a2=b2+a1a_2=b2+a_1、a3=b3+a2a_3=b3+a_2 等。

代码实现如下:

java 复制代码
public class Main {

	static int[] b = new int[8];
	static int[] a = { 0, 1, 2, 3, 4, 5, 7, 2 };

	public static void main(String[] args) {
		// 初始化拆分区间b
		for (int i = 1; i <= 7; i++) {
			b[i] = a[i] - a[i - 1];
		}
		// 对区间 1到 3 做 +5 操作
		b[1] += 5;
		b[3 + 1] -= 5;
		// 对区间 3 到5 做 -4 操作
		b[3] += -4;
		b[5 + 1] -= -4;
		// 则变化后的 a 为:
		// 编号从1开始输出
		for (int i = 1; i < 8; i++) {
			a[i] = b[i] + a[i - 1];
			System.out.printf("a%d = b%d + a%d = %d\n", i, i, i - 1, a[i]);
		}
	}

}

image.png
原理的话,其实理解起来就是拆分区间,会去存储该区间做加的值 val(正负都可用加),即在开始位的下标位置记录区间变更的值,那么之后每一个下标位置的数字都会加 val,比如:b[l]+=valb[l]+=val,相当于 a[l]+=vala[l]+=val、a[l+1]+=vala[l+1]+=val、a[l+2]+=vala[l+2]+=val、⋯\cdots、a[l+n]+=vala[l+n]+=val,那我们如何去结束这个“加”呢,限制我们的范围呢,其实同理,我们只需要在要结束的位置做减操作即可,如 a[r+1]−=vala[r+1]-=val,那么这个位置之后的数字都会再去减 val,相当于之前无关区间的值都去 +val,-val,那么综合起来就是值无变化,保证区间外的值不会影响,正确的还原。

java 复制代码
import java.util.*;

// 大学里的树木要打药
public class Main {

	// 差分数组
	static int[] b = new int[100006];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(); // 一共有多少颗树
		int m = sc.nextInt(); // 多少个区间
		while (m-- > 0) {
			int l = sc.nextInt();
			int r = sc.nextInt();
			int val = sc.nextInt();
			b[l + 1] += val;
			b[r + 1 + 1] -= val;
		}
		int sum = 0;
		for (int i = 1; i <= n; i++) {
			b[i] = b[i - 1] + b[i];
			sum += b[i];
		}
		System.out.print(sum);
	}

}

编程23 大学里的树木要维护

题目描述

教室外有 NN 棵树(树的编号从 1∼N1\sim N),根据不同的位置和树种,学校已经对其进行了多年的维护。

因为树的排列成线性,且非常长,我们可以将它们看作一条直线给他们编号。

由于已经维护了多年,每一个树都由学校的园艺人员进行了维护费用的统计。

每棵树的前期维护费用各不相同,但是由于未来需要要打药,所以有些树木的维护费用太高的话,就要重新种植。

由于维护费用也称区间分布,所以常常需要统一个区间里的树木的维护开销。

现给定一个长度为 NN 的数组 AA 以及 MM 个查询,AiA_i 表示第 ii 棵树的维护费用。对于每个查询包含一个区间,园艺人员想知道该区间内的树木维护的开销是多少。

请你编写程序帮帮他!

输入描述

每组输入的第一行有两个整数 NN 和 MM。NN 代表马路的共计多少棵树,MM 代表区间的数目,NN 和 MM 之间用一个空格隔开。(1≤N≤1000000,1≤M≤100000)(1\leq N\leq 1000000,1\leq M\leq 100000)

接下来的一行,包含 NN 个数 A1,A2,⋯ ,ANA_1,A_2,\cdots,A_N, 分别表示每棵树的维护费用,每个数之间用空格隔开。

接下来的 MM 行每行包含两个不同的整数,用一个空格隔开,表示一个区域的起始点 LL 和终止点 RR 的坐标。

输出描述

输出包括 MM 行,每一行只包含一个整数,表示维护的开销。

输入输出样例

示例

输入

sh 复制代码
10 3
7 5 6 4 2 5 0 8 5 3
1 5
2 6
3 7

输出

sh 复制代码
24
22
17

运行限制
image.png

题解

这题的话可以使用前缀和去解即可。

java 复制代码
import java.util.Scanner;

// 大学里的树木要维护
public class Main {

	static int[] a = new int[1000];
	static int[] sum = new int[1000];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(); // 一共有多少颗树
		int m = sc.nextInt(); // 多少个区间
		for (int i = 1; i <= n; i++) {
			a[i] = sc.nextInt();
			// 计算前缀和 sum[i] = sum[i-1] + a[i]
			sum[i] = sum[i - 1] + a[i];
		}
		while (m-- > 0) {
			int l = sc.nextInt();
			int r = sc.nextInt();
			// 区间 a[l,r] 的和为 sum[r] - sum[l-1]
			System.out.println(sum[r] - sum[l - 1]);
		}
	}
}

7. 并查集

并查集

并查集是大量的树(单个节点也算是树)经过合并生成一系列家族森林的过程。

每个集合也就是每棵树都是由根节点确定,也可以理解为每个家族的族长就是根节点。

举个数字和字母的例子如下。

初始森林:
image.png
经过的一系列合并后的状态(不唯一,举个例子):
image.png
最终合并后的状态:
注意:示意图的位置与存储物理位置无关,只代表逻辑关系。
image.png

存储结构

采用数组表示整个森林,初始时每个森林的树根为自己。

Java 存储与初始化:

java 复制代码
// 根据题目限制范围而定
static final int Maxn = 200;

static int fa[]=new int[Maxn+1];

static void init() {
    for(int i=0 ;i<=Maxn;i++)
        fa[i]=i;
}

查询

一般用递归法实现对元素的查询:递归访问父节点,直至根节点(根节点的标志就是父节点本身,所以也是为什么数组初始化时要 fa[i] = i ,好判断当前节点是否连接了其它树,其实就像链表,只不过用数组来存储上一个结点(或根节点)的位置)

根节点相同的元素属于同一个集合。所以判断 节点A、节点B 是否是同一个集合直接判断 find(A) 与 find(B) 即可。

按照这个思路,查询代码写起来也很简单。

java 复制代码
static int find(int x) {
    // 直到找到根节点
    if(fa[x] == x)
        return x;
    else
        return find(fa[x]);
}

这里有个问题,当树的链很长时,如下:
image.png
如果每次都查询最后一个,那么它就要递归很多次,时间复杂度很高。这里我们就要引入路径压缩。

路径压缩

路径压缩是为了解决当树的高度过高的时候,提高查询时效的方法。

解决方式也很简单,在递归的同时将路径压缩,那么上面的图经过一次查询后的效果如下。
image.png
其实实现代码也很简单,将之前代码修改下即可,如下:

java 复制代码
static int find(int x) {
     // 直到找到根节点
    if(x == fa[x])
        return x;
    else {
	// 将查到的根节点作为父节点
        fa[x] = find(fa[x]);
        // 返回父节点     
        return fa[x];
    }
}

合并

合并的方式很简单,就是把一颗树的根节点设置为另一棵树的根节点即可。

还有一种方式是按秩合并,但是我们使用路径压缩时间复杂度就已经很低了,如果在引入 rank 相对会有些复杂。而且对于我们的使用路径压缩一种方式就已经足够。并且路径压缩和按秩合并一起使用时会影响 rank 准确性,所以我们采用普通的合并与优化后的查找即可。
image.png
合并后:
image.png
代码如下:

java 复制代码
static void merge(int i, int j){
    fa[find(i)] = find(j);
}

合并优化

除此之外还有一个优化是启发式合并,其实这个启发式是泛指有很多的合并算法都叫启发式合并,我们这里讲其中一种常用的启发式合并。合并时,选择哪棵树的根节点作为新树的根节点会影响未来操作的复杂度。

我们可以按照子树大小去合并,小的合并到大的,以免发生退化。所以启发式合并的原理是在集合合并时将小的集合合并到大的集合里,也可以使 find 操作复杂度降低到 O(log⁡n)O(\log n),在集合合并时还要增加一个更新集合大小的操作。

代码如下:

java 复制代码
// 启发式合并
public void merge(int x, int y) {
    x = find(x);
    y = find(y);
    if (x != y) {
        if (sz[x] < sz[y]) {
            swap(x, y);
        }
        sz[x] += sz[y];
        fa[y] = x;
    }
}

如果是一般的并查集题目用路径压缩就可以了,当然两种优化都用的话复杂度可以降得更低。两种优化都使用的话单次操作的复杂度才是 O(n)O(n)

编程24 合根植物

ww 星球的一个种植园,被分成 m×nm\times n 个小格子(东西方向 mm 行,南北方向 nn 列)。每个格子里种了一株合根植物。

这种植物有个特点,它的根可能会沿着南北或东西方向伸展,从而与另一个格子的植物合成为一体。

如果我们告诉你哪些小格子间出现了连根现象,你能说出这个园中一共有多少株合根植物吗?

输入描述

第一行,两个整数 m,nm,n,用空格分开,表示格子的行数、列数(1<m,n≤1000)(1\lt m,n \leq1000)。

接下来一行,一个整数 k(0<k<105)k(0\lt k\lt 10^5),表示下面还有 kk 行数据。

接下来 kk 行,每行两个整数 a,ba,b,表示编号为 aa 的小格子和编号为 bb 的小格子合根了。

格子的编号一行一行,从上到下,从左到右编号。

比如:5×45 \times 4 的小格子,编号:

sh 复制代码
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20

输出描述

输出植物数量。

输入输出样例

示例

输入

sh 复制代码
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17

输出

sh 复制代码
5

样例说明

其合根情况参考下图:
image.png

运行限制
image.png

题解

这题的话是简单的并查集,我们每次合并两个节点时,让其中一个的根节点,作为另一个节点的根节点即可。

java 复制代码
import java.util.*;

// 合根植物
public class Main {

	static int N;
	// 存储每个节点的根节点
	static int[] father;

	/**
	 * 查找该节点的根
	 * 
	 * @param x
	 * @return
	 */
	private static int find(int x) {
		// 判断节点的根是不是自己,是的话直接返回
		if (x == father[x]) {
			return x;
		} else {
			// 路径压缩
			// 不是的话,递归去找它的根节点
			// 并将其父节点设为根节点
			father[x] = find(father[x]);
			return father[x];
		}
	}

	/**
	 * 合并两个点为同根
	 * 
	 * @param a
	 * @param b
	 */
	private static void merge(int a, int b) {
		int x = find(a);
		int y = find(b);
		// 直接让 b 作为 a 的根节点
		father[x] = y;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int m = sc.nextInt();
		int n = sc.nextInt();
		int k = sc.nextInt();

		N = m * n + 10; // 最大节点数,放宽些

		father = new int[N];

		// 初始化每个编号的根节点为自己
		for (int i = 0; i < N; i++) {
			father[i] = i;
		}

		for (int i = 0; i < k; i++) {
			int a = sc.nextInt();
			int b = sc.nextInt();
			// 合根
			merge(a, b);
		}

		int ans = 0;
		// 遍历所有节点,题目的编号是从1开始的
		for (int i = 1; i <= n * m; i++) {
			// 如果当前节点的根节点还是自己
			// 说明它就是根(一颗大的植物,其它植物连接着它)
			if (father[i] == i) {
				ans++;
			}
		}

		System.out.print(ans);

	}
}

编程25 修改数组

题目描述

给定一个长度为 NN 的数组 A=[A1,A2,⋯ ,AN]A=[A_1,A_2,\cdots,A_N],数组中有可能有重复出现的整数。

现在小明要按以下方法将其修改为没有重复整数的数组。 小明会依次修改 A2,A3,⋯ ,ANA_2,A_3,\cdots,A_N。

当修改 AiA_i; 时,小明会检查 AA,是否在 A1∼Ai−1A_1 \sim A_i -1 中出现过。如果出现过,则小明会给 AiA_i 加上 1;如果新的 AiA_i 仍在之前出现过,小明会持续给 AiA_i 加 1,直到 AiA_i,没有在 A1∼Ai−1A_1\sim A_i-1 中出现过。

当 ANA_N 也经过上述修改之后,显然 AA 数组中就没有重复的整数了。

现在给定初始的 AA 数组,请你计算出最终的 AA 数组。

输入描述

第一行包含一个整数 NN。

第二行包含 NN 个整数 A1,A2,⋯ ,ANA_1,A_2,\cdots,A_N。

其中,1≤N≤105,1≤Ai≤1061\leq N\leq10^5,1\leq A_i\leq10^6。

输出描述

输出 NN 个整数,依次是最终的 A1,A2,⋯ ,ANA_1,A_2,\cdots,A_N。

输入输出样例

示例

输入

sh 复制代码
5
2 1 1 3 4

输出

sh 复制代码
2 1 3 4 5

运行限制
image.png

题解

java 复制代码
import java.util.*;

public class Main {

	static final int N = 1000006;
	// 并查集数组,这里记录遇到哪一个数值时应该加几
	static int[] fa = new int[N];

	/**
	 * 找到根节点
	 * 
	 * @param x
	 * @return
	 */
	private static int find(int x) {
		if (fa[x] == x) {
			return x;
		} else {
			fa[x] = find(fa[x]);
			return fa[x];
		}
	}

	/**
	 * 合并
	 * 
	 * @param a
	 * @param b
	 */
	private static void merge(int a, int b) {
		int x = find(a);
		int y = find(b);
		// 小的合并进大的
		fa[x] = y;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		// 初始化每个编号的根节点为自己
		for (int i = 0; i < N; i++) {
			fa[i] = i;
		}

		for (int i = 0; i < n; i++) {
			int num = sc.nextInt();
			// 寻找遇到这个数时,应该输出多少
			int root = find(num);

			System.out.print(root + " ");
			// 这里我们存放下一次遇到这个数时所需输出的值
			// 题目每次遇到相同的数值时,就要在上一次的基础上 + 1
			// 故我们可以让 +1 的数作为这次遇到这个数时的根节点
			merge(root, root + 1);
		}

	}
}

8. 二分算法

二分查找算法

枚举查找即顺序查找,实现原理是逐个比较数组 a[0:n−1]a[0:n-1] 中的元素,直到找到元素 × 或搜索整个数组后确定 x 不在其中。最坏情况下需要比较 N 次,时间复杂度是 O(n)O(n),属于线性阶算法。

而二分查找是一种折半查找方法。该方法将 N 个元素分成大致相等的两部分,选取中间元素与查找的元素进行比较。如果相等,则查找成功;如果查找元素小于中间元素,则在左半区继续查找;如果查找元素大于中间元素,则在右半区继续查找。每次都将范围缩小至原来的一半,因此时间复杂度是 O(log⁡2n)O(\log 2n)。需要注意的是,二分查找的前提是数组有序,一般是从小到大排列。

折半查找的基本思想

在有序表中(low, high, Low<=high),取中问记录即 a=[(high+low)/2] 作为比较对象。

  • 若给定值与中间记录的关键码相等,则查找成功。
  • 若给定值小于中间记录的关键码,则在中间记录的左半区继续查找。
  • 若给定值大于中间记录的关键码,则在中间记录的右半区继续查找。

不断重复上述过程,直到查找成功或所查找的区域无记录,查找失败。

二分查找的特征

  1. 答案具有单调性。
  2. 二分答案的问题往往有固定的问法,例如:令最大值最小(最小值最大),求满足条件的最大(小)值等。

折半查找一般过程

image.png
sh 复制代码
Step 1:

假设存在一个有序数组:
下标[ 0   1   2   3   4   5   6   7   8    9    10   11   12 ]
数据[ 7   14  18  21  23  29  31  35   38   42   46   49  52 ]
      ↑                                                   ↑
    low=0                                              high=12

                            mid=(low+high)/2
                            mid=(0+12)/2
                            mid=6
                            [mid]=31 > 14,所以选择左半部分

操作:
    此时令low不变,high=mid-1=5

Step 2:

下标[ 0   1   2   3   4   5   6   7   8    9    10   11   12 ]
数据[ 7   14  18  21  23  29  31  35   38   42   46   49  52 ]
      ↑                   ↑
   low=0                 high=5

            mid=(low+high)/2
            mid=(0+6)/2
            mid=3
            [mid]=21 > 14,所以选择左半部分

操作:
    此时令low不变,high=mid-1=2

Step 3:

下标[ 0   1   2   3   4   5   6   7   8    9    10   11   12 ]
数据[ 7   14  18  21  23  29  31  35   38   42   46   49  52 ]
      ↑       ↑
   low=0    high=2

            mid=(low+high)/2
            mid=(0+2)/2
            mid=1
            [mid]=14 = 14  找到答案

操作:
    返回下标

整数二分法常用算法模板

java 复制代码
// 在单调递增序列 a 中查找>=x的数中最小的一个(即x或x的后继)
while (low < high) {
    int mid = (low + high) / 2;

    if (a[mid] >= x)
      high= mid;
    else
      low = mid + 1;
}

// 在单调递增序列 a 中查找<=x的数中最大的一个(即x或x的前驱)
while (low < high) {
    int mid = (low + high + 1) / 2;

    if (a[mid] <= x)
      low = mid;
    else
      high = mid - 1;
}

上面模板代码的适用范围广,当查询的序列中有 X 时这套代码就返回 X 的位置。如果没有 X,就返回 <=X 的数中最大的一个或者 >=X 的数中最小的一个。

实数二分法常用算法模板

我们对于一个实数去二分,我们需要知道自己去二分什么。比如我们求一个数的几次方根。那假如数字为 nn,开的根为 mm,则我们可以利用二分找到一个数 aa,使 ama^m 等于或很接近 nn,那么这个a即为我们需要的结果。

java 复制代码
//令eps 为小于题目精度一个数即可。

//比如有些题目说保留4位小数,0.0001 这种的。那么eps 就可以设置为五位小数的任意一个数 0.00001- 0.00009 等等都可以。一般为了保证精度我们选取精度 /100 的那个小数,即设置  eps= 0.0001/100 =1e-6。

while (l + eps < r) {
    double mid = (l + r) / 2;

    if (pd(mid))
      r = mid;
  else
      l = mid;
}

// 实数域二分,规定循环次数法

//通过循环一定次数达到精度要求,这个一般log2N< 精度即可。N为循环次数,在不超过时间复杂度的情况下,可以选择给N乘一个系数使得精度更高。

for (int i = 0; i < 100; i++) {

    double mid = (l + r) / 2;
    if (pd(mid))
      r = mid;
  else
      l = mid;
}

编程26 分巧克力

题目描述

儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。

小明一共有 NN 块巧克力,其中第 ii 块是 Hi×WiH_i\times W_i 的方格组成的长方形。为了公平起见,

小明需要从这 NN 块巧克力中切出 KK 块巧克力分给小朋友们。切出的巧克力需要满足:

  1. 形状是正方形,边长是整数;
  2. 大小相同;

例如一块 6x5 的巧克力可以切出 6 块 2x2 的巧克力或者 2 块 3x3 的巧克力。

当然小朋友们都希望得到的巧克力尽可能大,你能帮小明计算出最大的边长是多少么?

输入描述

第一行包含两个整数 N,K(1≤N,K≤105)N,K(1\leq N,K\leq10^5)。

以下 N 行每行包含两个整数 Hi,Wi(1≤Hi,Wi≤105)H_i,W_i(1\leq H_i,W_i\leq10^5)。

输入保证每位小朋友至少能获得一块 1x1 的巧克力。

输出描述

输出切出的正方形巧克力最大可能的边长。

输入输出样例

示例

输入

sh 复制代码
2 10
6 5
5 6

输出

sh 复制代码
2

运行限制
image.png

题解

这题的话,求从一个长方形巧克力中,切分出尽可能大的正方形巧克力,并够让每个小朋友都分的这么大的巧克力,以及每个小朋友至少分得边长为 1 的正方形巧克力。

那求尽可能最大的问题,我们如果确定了上下限,那么就可以利用二分法求出尽可能大的情况。

  • 确定上下限:边长至少为1的正方形,那么就会下限,上限的话,题目要求从每个巧克力切割出正方形,故 n 个巧克力中的最大的边,即为我们可以分割的正方形边的上限。
  • 判断边长是否满足要求:求一块长方形(h∗wh * w) 的巧克力,能划分出多少正方形(l∗ll * l)巧克力,那么我们求出矩形的长宽能分配出多少个正方形,它们的乘积就是划分的个数。

count=(h/l)∗(w/l)count=(h/l)*(w/l)

这里为啥不直接用长方形的面积去除以正方形的面积求出个数呢?

因为如果长方形很大,它的宽很小,但刚好比正方形的边长一些,而长很大,那么余下部分的面积可能也够一个正方形,那么求出来的值就不是我们要的了,因为题目要的是一个正方形,那余下部分的肯定是矩形。

image.png
java 复制代码
import java.util.Scanner;

// 分巧克力
public class Main {

	static final int N = (int) 1e5 + 10;
	static int[] h = new int[N];
	static int[] w = new int[N];
	static int n; // n 块巧克力
	static int k; // k位小朋友

	/**
	 * 判断当前找到的边是否够分k份巧克力
	 * 
	 * @param l 正方形的边
	 * @return
	 */
	private static boolean pd(int l) {
		// 长方形面积h*w,正方形面积为 l*l,那么这个长方形可以分得 h*w/(l*l) 个正方形
		int count = 0;
		for (int i = 0; i < n; i++) {
			// 我们把长方形的 长、宽 按当前需要判断的正方形的 边长 进行划分
			// 这个代表当前这个矩形巧克力划分成多少颗正方形巧克力

			// 可能宽很短,没法达到正方形的长度,但长很长,计算出来的份数可能有误差
			// int c = (h[i] * w[i]) / (l * l);

			// 这里计算长和宽分别能分出多少份正方形的长和宽,那就可以算出能分出多少个正方形
			int d = (h[i] / l) * (w[i] / l);
			count += d;
			// 如果能分得的巧克力满足小朋友数量,则直接返回,说明
			if (count >= k) {
				return true;
			}
		}
		return false;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		k = sc.nextInt();

		for (int i = 0; i < n; i++) {
			h[i] = sc.nextInt();
			w[i] = sc.nextInt();
		}

		// 找打二分查找的上界(由最大面积开始二分查找,直到找到面积为2的情况)
		int high = 0;
		for (int i = 0; i < n; i++) {
			// 找出边最长的作为正方形的上边界
			high = Math.max(high, h[i]);
			high = Math.max(high, w[i]);
		}

		// 题目将巧克力分成正方形,每个小朋友最少分得 1x1 的巧克力
		int low = 1;

		// 题目要求尽可能最大,故我们可以用二分法来查找出尽可能满足条件的最大值,
		// 也就是接近最大边的值
		int mid = 0; // 最坏的情况可能是0个

		// 左右指针相遇时,即找到最大的值了
		while (low < high) {
			mid = (low + high + 1) / 2;
			// 将当前得到的中间值作为 正方形的边
			// 如果满足分成 k 份正方形巧克力,则代表找到了下限,这个mid即为下限
			if (pd(mid)) {
				low = mid;
			} else {
				// 如果不能分成k份,则说明当前这个边的值较大,我们得重新调整上界
				high = mid - 1;
			}
		}

		// 当前上下限指针相遇时,即找到了最大可能得边
		System.out.println(low);
	}
}

编程27 M次方根

题目描述

小AA最近在学高等数学,他发现了一道题,求三次根号下 2727 。

现在已知,小AA开始计算,11 的三次方得 11,22 的三次方得 88,33 的三次方得 2727,然后他很高兴的填上了 33。接着他要求 55 次根号下 164164。

然后他开始 11 的三次方得 11,22 的三次方得 88,33的三次方得 27⋯27\cdots

直到他算到了秃头,也没有找到答案。

这时一旁的小BB看不下去了,说这题答案又不是个整数。

小AA震惊,原来如此。

作为程序高手的小AA,打算设计一个程序用于求解 MM 次跟下 NN 的值。

但是由于要考虑精度范围,答案必须要保留 77 位小数,三次根号下 2727 都要掰手指的小A又怎么会设计呢。

请你帮小A设计一个程序用于求解 MM 次根号 NN。

输入描述

每组输入的第一行有两个整数 NN 和 MM,数据间用空格隔开。

1≤N≤105,1≤M≤102,M<N1\leq N\leq10^5,1\leq M\leq10^2,M<N。

输出描述

输出一个实数表示答案(请保留小数点后 77 位)。

输入输出样例

示例

输入

sh 复制代码
27 3

输出

sh 复制代码
3.0000000

运行限制
image.png

题解

这题的话可以直接用 Java 自带的数学工具类 Math 求解,也可以用我们的实数二分法来解决。下边是二分法的解题思路:

  • 我们规定实数二分的上下限 r 与 l,为 n 和 0;
  • 接着题目要求保留小数点7位,故我们进度要在8到9位小数,才能不影响前7位小数的精度,这里我的精度保留到第九位,即 1e-9。这个精度用于缩小左右指针相等的误差范围。
  • 接着我们利用二分的思想,不断地去找出 mid,缩小查找范围。如果 mid 的 m 次方能大于等于 n,则说明mid是我们下一次查找的上限,如果 mid 的 m 次方都无法达到 n,说明 mid 太小了,则要作为我们的下限。如此反复,直到左右指针相遇的情况(在误差范围内相等),则说明我们找到了那个 mid,存储在 l 或者 r 中。输出其中一个即可。
java 复制代码
import java.util.Scanner;

// M次方根
public class Main {

	static int n;
	// 题目要精确到企微小数,这里我用9位去算,避免影响7位的精度
	static double eps = 1e-9;

	private static boolean pd(double x, int m) {
		double sum = 1;
		// 计算 x 的 m 次方
		while (m-- > 0) {
			sum *= x;
		}
		// 如果 x 的 m 次方大于 n,说明这个数满足条件
		if (sum >= n) {
			return true;
		}

		return false;
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		int m = sc.nextInt();

		// 定义二分上下界
		double l = 0;
		double r = n;

		double mid = 0;

		// 实数二分
		while (l + eps < r) {
			mid = (l + r) / 2;
			// 判断该数的 m 次方是否大于等于 n
			if (pd(mid, m)) {
				// 大于等于n,让这个数作为上限,继续缩小范围
				r = mid;
			} else {
				// m次方 小于 n,说明该数太小,应作为下限,缩小范围
				l = mid;
			}
		}
		// 左右指针相遇,输出结果
		System.out.printf("%.7f\n", l);
		// 当然,题目可以直接用数学工具解决这题
//		 System.out.printf("%.7f\n", Math.pow(n, (double) 1 / m));
	}
}

9. 贪心算法

贪心算法

基本概念

贪心算法与枚举法的不同之处在于每个子问题都选择最优的情况,然后向下继续进行,且不能回湖。枚举法是将所有情况都考虑然后选出最优的情况。

贪心算法,在解决问题时,不从整体考虑,而是采用一种一眼看到局部最优解的选择方式。并且,贪心算法没有固定的模板可以遵循,每个题目都有不同的贪心策略,所以算法设计的关键在于贪心策略的选择。

贪心算法有一个必须注意的事情。贪心算法对于问题的要求是,所有的选择必须是无后效性的,即当前的选择不能影响后续选择对于结果的影响。

贪心算法主要适用于最优化问题,例如:最小生成树问题。有时候贪心算法并不能得到最优答案,但是能得到精确答案的近似结果。有时可以辅助其他算法得到不那么精确的结果。

适用范围

符合贪心策略:

所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择,即贪心选择来达到。这是贪心算法可行的第一个基本要素,也是贪心算法与动态规划算法的主要区别。

贪心选择性质就是指,该问题的每一步选择都在选择最优的情况下能够导致最终问题的答案也是最优。

或者说是无后效性,如果该问题的每一步选择都对后续的选择没有影响,就可以应用贪心算法。

设计步骤

按照定义设计:

  1. 证明原问题的最优解之一可以由贪心选择得到。
  2. 将最优化问题转化为这样一个问题,即先做出选择,再解决剩下的一个子问题。
  3. 对每一子问题一一求解,得到子问题的局部最优解;
  4. 将子问题的解局部最优解合成原问题的一个解。

伪代码

关于问题 Q

java 复制代码
while(Q.hasNextStep) {
    Select(Q.nowBestSelect);
    Q.NextStep
}

Select(Q.nowBestSelect);

编程28 找零问题

题目描述

蓝桥商店的老板需要找零 nn 元钱。

钱币的面额有:100100 元、5050 元、2020 元、55 元、11 元,问如何找零使得所需钱币的数量最少?

注意:nn 可能为 00,也能为几百元(别问,问就是来着里微信
提现来了)

输入描述

在第一行给出测试例个数 NN,代表需要找零的钱数。
1≤N≤1051\leq N\leq10^5。

输出描述
输出共有 55 行,每一行输出数据输出找零的金额与数量,详情看样例。

输入输出样例

示例

输入

sh 复制代码
365

输出

sh 复制代码
100:3
50:1
20:0
5:3
1:0

运行限制
image.png

题解

我们一般找零钱都是从大的面额开始找,找到后,余下的钱再从小的面额找,这其实就是贪心的思想。这样找到的所花的纸张数肯定是最小的。

java 复制代码
import java.util.Scanner;

public class Main {

	// 零钱从大到小排列
	static int[] money = { 100, 50, 20, 5, 1 };
	// 找零的张数
	static int[] res = new int[5];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		// 找零
		solve(n);
		for (int i = 0; i < 5; i++) {
			System.out.printf("%d:%d\n", money[i], res[i]);
		}
	}

	/**
	 * 找零
	 * 
	 * @param n
	 */
	private static void solve(int n) {
		// 从最大张面额的钱开始找,所花的钱币数量肯定是最少的
		for (int i = 0; i < 5; i++) {
			// 记录当前剩余要找的钱,花了当前这个面额的钱多少张
			res[i] = n / money[i];
			// 更新剩余要找的钱
//			n -= (money[i] * res[i]);
			n %= money[i];
		}
	}
}

编程29 小B的宿舍

题目描述

小 BB 的宿舍楼沿着走廊南北向的两边各有 200200 个房间,如下所示:

sh 复制代码
[房间1][房间3][房间5][房间7][房间9 ]...[房间399]
----------------------------------------------
                   走廊
----------------------------------------------
[房间2][房间4][房间6][房间8][房间10]...[房间400]

最近,由于转专业和专业分流的原因,宿舍将迎来新的调整,以便组成新的班级后方便管理。

但是由于走廊狭窄,走廊里只能通过一个搬运的物品(可以同向也可以反向),因此必须指定高效的搬运计划。

老师给了每位同学下达了以下要求,让同学们体现收拾好行李,然后给每位同学 1010 分钟的时间搬运。

当从房间 ii 搬运行李到 jj 时,ii 与 jj 之间的走廊都会被占用。所以,1010分钟之内同一段走廊最多 11 个人同时搬运,不重叠的走廊也可以同时搬运。

小 BB 的老师是个数学老师,经过运筹学一通计算他得到了最优的搬运计划。

虽然计划不唯一,但是最优值唯一,请问这个最短时间是多少?

输入描述
输入数据有 TT 组测试例,在第一行给出测试例个数工。

每个测试例的第一行是一个整数 N(1≤N≤200)N(1\leq N \leq200),表示要搬运行李的人数。

接下来 NN 行,每行两个正整数 ss 和 tt,表示一个人,要将行李是从房间 ss 移到到房间 tt。

输出描述

每组输入都有一行输出数据,为一整数 TimeTime,表示完成任务所花费的最小时间。

输入输出样例

示例

输入

sh 复制代码
3
4
10 20
30 40
50 60
70 80
2
1 3
2 200
3
10 100
20 80
30 50

输出

sh 复制代码
10
20
30

运行限制
image.png

题解

这题的话,我们发现每两个相邻编号的房间共用一个走廊道,故我们可以给走廊编号,一共400个房间,那就有200个走廊号。接着可以统计其中哪部分走廊号占用次数最多,那么它就是最短时间,因为同一时间同一段走廊只能允许一趟搬运,只能错开搬运,故其中重叠部分最多的也就是所花时间最短的情况。

java 复制代码
import java.util.*;

public class Main {
  	// 走廊号,对应南北方向相同列的房间的走廊号
	// 比如:房间1与房间2的走廊号为0
	static int[] hallway = new int[201];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt(); // t组测试数据
		while (t-- > 0) {
			int n = sc.nextInt();
			hallway = new int[201];
			int from, to; // 搬运的起点,终点的走廊号
			// 记录最大占用次数,可以理解为占用了多少个10分钟
			int maxAns = 0;

			// 计算每一次搬运重叠的走廊编号,那么之后重叠最多即为占用时间最少的情况
			// 因为有重叠的部分是无法避免的,只能错开
			while (n-- > 0) {
				int a = sc.nextInt(); // 搬运的起点房间号
				int b = sc.nextInt(); // 搬运的终点房间号

				// 每两个房间共用一个走廊号
				// 映射房间对应的走廊号,房间的编号是从1开始的
				from = (a - 1) / 2;
				to = (b - 1) / 2;

				// 这里我们关心他们之间的占用时间
				// 为了方便,我们让 from 小于 to
				if (from > to) {
					int temp = from;
					from = to;
					to = temp;
				}
				// 标记当前这一趟所占用的走廊
				for (int i = from; i <= to; i++) {
					// 累计这一个走廊号的占用次数
					hallway[i]++;
					// 并更新占用次数最多的走廊
					// 其就是能使其他房间尽可能一起搬运的最少时间
					// 因为重叠的部分是无法避免的,只能分开搬运
					maxAns = Math.max(maxAns, hallway[i]);
				}
			}
			System.out.println(maxAns * 10);
		}
	}
}

10. 动态规划

动态规划

为什么使用动态规划?

我们先回忆一下贪心问题。

贪心又称贪婪算法。是一种在每一步选择中都采取在当前状态下最好或最优(即最有利)的选择,从而使得问题得到全局最优解。

它的特点:

贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择,即贪心选择来达到。

这是贪心算法可行的第一个基本要素,也是贪心算法与动态规划算法的主要区别。

贪心选择性质就是,该问题的每一步选择都在选择最优的情况下能够导致最终问题的答案也是最优。

其实贪心和动态规划的区别,你可以理解为一个是正推,一眼就能看出来最优子结构,依次技照最优子结构选择每个过程最优选择即可。

而动态规划是没办法按照题目的意思直接得到最有优子结构,如下文所述:

多阶段决策过程最优化问题

动态规划问题,是运筹学的一个分支,动态规划主要用于求解以时间划分阶段的动态过程的优化问题。

在实际生活中,动态规划问题与贪心问题相似,都是完成某一事件的过程可以划分成多个阶段。

但是与贪心不同的是动态规划的每个状态之间都会相互影响和相互干涉,也就是说在某一阶段做出的决策会影响整个事件的最终结果。

因为阶段是有先后的,所以某一阶段的选取受之前阶段的影响,他也会影响后面的阶段。

多阶段决策问题:

多阶段决策过程问题,就是一类在每一阶段都需要做出选择,且某一阶段的决策受前面所有阶段决策后的状态影响,他的决策又会影响后续的决策。

这样一类问题就是多阶段决策问题。

多阶段决策过程最优化问题:

在多阶段决策问题中,各个阶段采取的决策,通常与时间相关,但有时又与其他的线性的变量相关。

我们前面说到,某个阶段的决策是在前面做完了的决策引发的某一个状态开始进行决策的。

而现在做的决策又会使得状态进行转移,那么又影响了下次进行决策的状态。

所以说作决策时的状态是动态的,规划是解决最优化问题的方式,所以解决这种多阶段决策过程最优化的方法叫做动态规划。

术语解释

  • 阶段:把所给求解问题的过程恰当地分成若干个相互联系的阶段,以便于求解,过程不同,阶段数就可能不同
  • 状态:述事物的性质,不同事物有不同的性质,因而用不同的状态来刻画。对问题的求解状态的描述是分阶段的
  • 决策:根据题意要求,对每个阶段所做出的某种选择性操作
  • 策略:由每个阶段的决策组成的序列称为策略
  • 状态转移方程:用数学公式描述与阶段相关的状态间的演变规律

能采用动态规划求解的问题的性质

  • 最优化原理:
    如果问题的最优解所包含的子问题的解也是最优的,就称该问题具有最优子结构,即满足最优化原理。
  • 无后效性:
    即某阶段状态一旦确定,就不受这个状态以后决策的影响。也就是说,某状态以后的过程不会影响以前的状态,只与当前状态有关。
  • 有重叠子问题:
    即子问题之间是不独立的,一个子问题在下一阶段决策中可能被多次使用到。(该性质并不是动态规划适用的必要条件,但是如果没有这条性质,动态规划算法同其他算法相比就不具备优势)

解题步骤

  • 拆分问题
  • 定义状态(并找出初状态)
  • 找到状态转移
  • 逆推找最优子结构
  • 写出 DP 状态转移方程。

一般的模型方法

  • 递归搜索法
  • 记忆化搜索(记忆化暴力)
  • 递推式法

背包问题

三种背包的基本模型:

  • 0-1 背包
  • 完全背包
  • 多重背包问题

背包问题基本都是不可拆分背包,因为可拆分背包是贪心去求解的问题。

0-1 背包问题

0-1 背包的问题是什么呢?

其问题的简单表述为,有 N 件物品,每件物品只有一件。每个物品都有一个价值 wiw_i,每件物品都有一个占一个部分空间 cic_i,已知你的背包共计可承重 C(Contains),现在让你求你的背包最多装得下多少 wMaxw_{Max},即求你背包中物品的最大价值 wMaxw_{Max}。

模板

1、定义变量并输入
java 复制代码
import java.util.*;

public  class  Main {

    static int []c;
    static int []w;
    static int dp[];
    static int C;

    static int n;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        n=in.nextInt();
        C=in.nextInt();

        c=new int[n+50];
        w=new int[n+50];
        dp=new int [C+50];

        for (int i = 0; i < n; i++) {
             c[i]=in.nextInt();
             w[i]=in.nextInt();;
        }
    }
}
2、执行算法

我们先找到状态转移方程

在 0-1 背包问题中,对于每件物品 i,有两种选择:要么完全不考虑这件物品(即不放入背包),要么就把它放入背包(如果背包的剩余容量允许)。因此,状态转移方程考虑的是从之前的状态转移来的最优解。

dp[i][j]=max(dp[i−1][j],dp[i−1][j−c[i]]+w[i])dp[i][j]=max(dp[i-1][j],dp[i-1][j-c[i]]+w[i])

这里:

  • dp[i][j]dp[i][j] 表示考虑到第 i 件物品时,背包容量为 j 时的最大价值。
  • c[i]c[i] 是第 i 件物品的重量。
  • w[i]w[i] 是第 i 件物品的价值。
  • 如果不选择第 i 件物品,那么最大价值保持为 dp[i−1][j]dp[i-1][j],即背包容量为 j 时的最大价值不变。
  • 如果选择了第 i 件物品,前提是这个物品可以放入背包中(即j−c[i]≥0j-c[i]\ge0),那么最大价值是 dp[i−1][j−c[i]]+w[i]dp[i-1][j-c[i]]+w[i]。即在当前背包容量允许放入第 i 件物品的情况下,选择放入这件物品,并加上这件物品的价值。
java 复制代码
for(int i=0;i<n;i++){
    for(int j=0;j<=C;j++){
        if(j>=c[i])
            dp[i][j]=max(dp[i][j],dp[i-1][j-c[i]]+w[i]);
    }
}
System.out.println(dp[C]);
3、空间优化

因为状态转移每次只与上一层有关,所以用一个一维数组就可以。

为什么从大到小遍历,看 dp[j]=dp[j−c[i]]+w[i]dp[j] = dp[j - c[i]] + w[i] 这一状态转移,是根据小的改大的,如果先把小的改了,那小的还会被用到,数据就不对了,所以从大到小。

java 复制代码
for (int i = 0; i < n; i++) //遍历每一件物品
{
      for (int j = C; j >= c[i]; j--)
            //遍历背包容量,表示在上一层的基础上,容量为J时,第i件物品装或不装的最优解;
           dp[j] = max(dp[j - c[i]] + w[i], dp[j]);
}

System.out.println(dp[C]);
4、初始化细节
  • 装满 dp[0]=0dp[0]=0,其余赋值 −INF-INF;
  • 不裝满全初始化为 00;
java 复制代码
//装满
Arrays.fill(dp, -0x3f3f3f3f);
dp[0]=0;

//不装满
Arrays.fill(dp, 0);

完全背包问题

完全背包是背包问题的入门的问题。

根据 0-1 背包写出模板也是很简单的。

完全背包的问题是什么呢?

其问题的简单表述为,有 N 件物品,每件物品有无数件。每个物品都有一个价值 wiw_i,每件物品都有一个占一个部分空间 cic_i,已知你的背包共计可承重 C(Contains),现在让你求你的背包最多装得下多少 wMaxw_{Max},即求你背包中物品的最大价值 wMaxw_{Max}。

模板

1、定义变量并输入

参考 0-1 背包。

2、执行算法

我们先去找到状态转移方程

dp[i][j]=max(dp[i][j],dp[i][j-c[i]]+w[i])

含义,选到第 ii 件物品,且背包现在重量为 jj。

那么考虑这个状态会由什么状态转移而来,肯定是选到第 i一1i一1 件的时候,或者选了若干次第 ii 件。

如果不选第 ii 种,那么就是由 dp[i-1][j] 转移而来。

如果选了第 ii 件,那么就是由 dp[i][j-c[i]] 转移而来。

或者在某一刻,不在选第 ii 件了,那么就是有 dp[i][j] 转移而来。

那么已知 dp[i][j-c[i]] 和 dp[i][j] 都为各自最优的状态,那我们直接取最优状态即可。

java 复制代码
for(int i=0;i<n;i++) {
    for(int j=0;j<=C;j++) {
        dp[i][j]=dp[i-1][j];
        if(j>=c[i])dp[i][j]=max(dp[i][j],dp[i][j-c[i]]+w[i]);
    }
}
System.out.println(dp[n][C]);
3、空间优化

因为状态转移每次只与上一层有关,所以用一个一维数组就可以。

为什么从小到大遍历,看 dp[j]=dp[j−c[i]]+w[i]dp[j] = dp[j - c[i]] + w[i] 这一状态转移,是根据小的改大的,而此时的含义为选了 x 件后的容量与质量,跟 01 背包类似,但含义不同,处理方式上也有本质区别,处理完一件后在处理下件。(取已经考虑过是否放入物品 i 时的小容量的最优解)

java 复制代码
for (int i = 0; i < n; i++) //遍历每一件物品
{
	for(int j=c[i];j<=C;j++)
      		//遍历背包容量,表示在上一层的基础上,容量为J时,第i件物品装或不装的最优解;
                dp[j] = max(dp[j - c[i]] + w[i], dp[j]);
}
System.out.println(dp[C]);
4、初始化细节

与 0 - 1 背包问题相同

  • 装满 dp[0]=0dp[0]=0,其余赋值 −INF-INF;
  • 不裝满全初始化为 00;

多重背包问题

多重背包的问题是什么呢?

其问题的简单表述为,有 N 件物品,每件物品有 sis_i 件。每个物品都有一个价值wiw_i,每件物品都有一个占一个部分空间 cic_i,已知你的背包共计可承重 C(Contains),现在让你求你的背包最多装得下多少 wMaxw_{Max},即求你背包中物品的最大价值 wMaxw_{Max}。

模板

1、定义变量并输入

参考 0-1 背包。

2、执行算法

这里我们直接空间优化,不讲解二维做法:

多重背包是可以不选,也可以选 1 个,可以选多个,而 0-1 背包只能选 0 个或者 1 个。

那就直接把种物品分开,即可比如:

每个盘子 3 块钱,我有 2 个。每双筷子 1 块钱,我有 10 双,每对刀叉 3 块钱,我有 3 个。

那么我就可以拆成,有 2 个三块的盘子,每个可以选也可以不选,就变成了 0-1 背包。

也就是说,对于每种是可以选多个,那就直接拆分成独立的个体就可以了。

java 复制代码
//遍历每一个物品
for(int i=0;i<n;i++) {
    //遍历物品的数量
    for(int j=0;j<=s[i];j++) {
        //当做01背包来处理
        for(int k=C;k>=c[i];k--) {
            //取01背包情况的dp[k]和dp[k-c[i]]+w[i]的最大值
            dp[k]=max(dp[k],dp[k-c[i]]+w[i]);
        }
    }
}
System.out.println(dp[C]);

不顾这样做大概率会超时,我们换一种理解方式:

在这两种问题中,我们需要考虑每个物品选择取或不取的情况,通过动态规划来求解最优解。

01背包问题中,对于每个物品 i,我们有两个选择:选取或不选取。状态转移方程为:dp[j]=max(dp[j],dp[j−v[i]]+w[i])dp[j]=max(dp[j],dp[j-v[i]]+w[i])

多重背包问题中,对于每个物品i,我们可以选择取00个、11个、22个…直到s[i]s[i]个。状态转移方程为:dp[j]=max(dp[j],dp[j−v[i]⋅k]+w[i]⋅k)dp[j]=max(dp[j],dp[j-v[i]\cdot k]+w[i]\cdot k)其中,k 的取值范围是 0,1,2,⋯ ,s[i]0,1,2,\cdots,s[i]。

这两个问题的解决思路相似,都是通过填充一个二维的动态规划数组 dpdp,其中 dp[j]dp[j] 表示背包容量为 j 时的最优解。在状态转移时,我们考虑了每个物品的选择情况,求解最终的最优解。

3、初始化细节:

与 0 - 1 背包问题相同

  • 装满 dp[0]=0dp[0]=0,其余赋值 −INF-INF;
  • 不裝满全初始化为 00;

线性 DP

普通线性 DP

线性 DP 是动态规划问题中的一类问题,指状态之间有线性关系的动态规划问题。

这类问题不像是我们讲的背包等问题有固定的模板。

少数常见的线性 DP 问题也有模板,比如我们讲的 LISLIS 和 LCSLCS 问题。

大部分还是需要根据题目进行推导,基本没有什么规律可循。

大部分线性规划的问题,都需要自己首先定义状态,找到决策,推导状态转移方程。

最长公共子序列问题(LCS)

一个给定序列的子序列,是在该序列中删去若干元素后得到的序列。

例如:X = {A,B,C,B,D,A,B},它的子序列有 {A,B,C,B,A}、{A,B,D}、{B,C,D,B} 等。

给定两个序列 X 和 Y,当另一序列 Z 既是 X 的子序列又是 Y 的子序列时,称 Z 是序列 X 和 Y 的公共子序列。

最长公共子序列是长度最长的子序列。

暴力法

先找出 A 的所有子序列,然后一一验证是否为 Y 的子序列。
如果 A 有 m 个元素,那么 A 有 2m2^m 个子序列;B 有 n 个元素;总复杂大于 O(n2m)O(n2^m)。

动态规划

求序列 Ai(a1 ~ ai)和 Bj(b1 ~ bj)的最长公共子序列的长度。

image.png

在 m 与 n 序列中,遍历找出长度为 i + 1 与 j + 1 部分序列的最长公共子序列,从最小的子问题开始找出最优解。

定义:dp[i][j],表示存储以 a[i] 与 b[j] 结尾,它们其中最长公共子序列长度,故最终的 dp[n][m] 是序列 A 与 序列 B 的最长公共子序列。算法复杂度为O(nm)O(nm)

过程如下:

sh 复制代码
dp[0][0]:找出 {a1} 与 {b1} 的最长公共子序列长度。
dp[0][1]:找出 {a1} 与 {b1,b2} 的最长子序列长度。
dp[3][2]:找出 {a1,a2,a3,a4} 与 {b1,b2,b3} 的最长公共子序列长度。
...
dp[n-1][m-1]:找出 {a1,a2,...an} 与 {b1,b2,...,bm} 的最长公共子序列长度。

分解为2种情况:

(1)当 ai=bja_i = b_j 时,已求得 Ai−1A_{i-1} 和 Bj−1B_{j-1} 的最长公共子序列,在其尾部加上 aia_i 或 bjb_j 即可得到 AiA_i 和 BjB_j 的最长公共子序列。状态转移方程:

java 复制代码
dp[i][j] = dp[i - 1][j - 1] + 1;

简单理解就是:上一次求出长度为 i-1,j-1 时得到最优解(dp[i - 1][j - 1]),那么在第 i 个元素与第 j 个元素进行比较后也相等时,则 a[i] 与 b[j] 也是公共子序列,那么将其加入未加入 i 时所得到的最长子序列(dp[i - 1][j - 1]),就是长度为 i 的 A 序列 与 长度为 j 的 B 序列的最长子序列长度。

(2)当 ai!=bja_i != b_j 时,求解两个子问题:Ai−1A_{i-1} 和 BjB_j 的最长公共子序列;AiA_i 和 Bj−1B_{j-1} 的最长公共子序列。取最大值,状态转移方程:

java 复制代码
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);

image.png
简单理解就是, i 和 j 位置的元素不是公共子序列,故不选它,那么分别得到与上一次未考虑第 i个元素与第 j 个元素时的最优解,也就是:dp[i - 1][j]、dp[i][j - 1],找到两者的最大值作为当前长度为 i 和 j 时最优解。

下边是伪代码

java 复制代码
int[][] dp = new int[Max][Max];

dp[0][0] = 0;
for (int i = 0; i < n; i++) {
	for (int j = 0; j < m; j++) {
		if (a[i] == b[j]) {
			dp[i + 1][j + 1] = dp[i][j] + 1;
		} else {
			dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]);
		}
	}
}

System.out.print(dp[n][m]);

最长递增子序列问题(LIS)

给定一个长度为 n 的数组,找出一个最长的单调递增子序列。

例:序列A={5,6,7,4,2,8,3},它最长的单调递增子序列为{5,6,7,8}, 长度为4。

定义状态 dp[i]:表示以第 i 个数为结尾的最长递增子序列的长度。

状态转移方程:dp[i] = max{dp[j]} + 1,0<j<i;Aj<Ai0 < j< i;A_j<A_i

复杂度:j 在 0 ~ 1 之间滑动,复杂度 O(n)O(n);i 的变动范围也是 O(n)O(n);总复杂度 O(n2)O(n^2)。

步骤

我们首先定义状态:

我们定义 dp[i] 为以 a[i] 结尾的最长上升子序列长度。

设置 j 为小于 i 的某一点,那么当 a[j]< a[i] 时,必然有,以 a[j] 结尾的最长上升子序列,现在能以 a[i]结尾,并且长度+1。

因为 j < i 且 a[j]<a[i],满足上升子序列的要求。

所以 dp[i] 的一条转移路径为 dp[i] = dp[j]+1

但是 j 是比 i 小的某一个值,转移到 dp[i] 这一状态的值很多,所以我们要选择最优状态。

所以 dp[i] 的状态转移:

dp[i] = Math.max(dp[j] + 1, dp[i]);

那么当 a[j]>a[i]时

此时肯定不满足上升子序列,所以 dp[i] 与 dp[j] 毫无关联。

由此我们可以写出 LIS 的算法部分。

例题(蓝桥骑士)

题目描述

小明是蓝桥王国的骑士,他喜欢不断突破自我。这天蓝桥国王给他安排了 N 个对手,他们的战力值分别为 a1,a2,...,an,且按顺序阻挡在小明的前方。对于这些对手小明可以选择挑战,也可以选择避战。身为高傲的骑士,小明从不走回头路,且只愿意挑战战力值越来越高的对手。请你算算小明最多会挑战多少名对手。

输入描述

第一行是整数 N,表示对手的个数,第二行是 N 个整数a1,a2,...,an,表示对手战力值。 1≤N≤3×1051 \leq N\leq 3\times10^5

输出描述

输出一行整数表示答案。

输入输出样例

示例 1

输入

sh 复制代码
6
1 4 2 2 5 6

输出

sh 复制代码
4

运行限制

  • 最大运行时间:1s
  • 最大运行内存: 128M
题解

分析:小明每次只会挑战战力越来越高的对手,不走回头路,也就是说挑战了战力 100 的,那么之后就不会找战力相同或者低的对手挑战。那么其实可以看成在一个序列总找出最长递增子序列。

java 复制代码
import java.util.Scanner;

// 蓝桥骑士
public class Main {

	static int N;
	static int[] arr;
	static int[] dp; // 存储处理到第 i 个元素时的最长递增子序列长度

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		arr = new int[N];
		dp = new int[N];
		for (int i = 0; i < N; i++) {
			arr[i] = sc.nextInt();
			// 初值,每个位置的递增子序列长度为1
			dp[i] = 1;
		}

		// 找到终点为 i 的最长递增子序列长度
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < i; j++) {
				// 如果前 i 个元素中,比终点 i 位置的元素值小
				// 那它对于终点 i 是递增的
				// 且终点为 j 时的最优解加上当前的 i 如果比现在的最优解好,则更新。
				if (arr[i] > arr[j] && dp[j] + 1 > dp[i]) {
					dp[i] = dp[j] + 1;
				}
			}
		}
		System.out.print(dp[N - 1]);
	}
}

编程30 数字三角形

题目描述

image.png

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径,把路径上面的数加起来可以得到一个和,你的任务就是找到最大的和(路径上的每一步只可沿左斜线向下或右斜线向下走)。

输入描述

输入的第一行包含一个整数 N(1≤N≤100){N(1\leq N\leq100)},表示三角形的行数。

下面的 N{N} 行给出数字三角形。数字三角形上的数都是0{0}至99{99}之间的整数。

输出描述

输出一个整数,表示答案。

输入输出样例

示例

输入

sh 复制代码
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

输出

sh 复制代码
30

运行限制
image.png

题解

java 复制代码
import java.util.*;

public class Main {

	static int[][] dp;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();

		dp = new int[n][];

		// 存储三角形
		for (int i = 0; i < n; i++) {
			dp[i] = new int[i + 1];
			for (int j = 0; j < i + 1; j++) {
				dp[i][j] = sc.nextInt();
			}
		}

		// 从倒数第二层开始,逐步计算当前与下一层的最有结果
		for (int i = n - 2; i >= 0; i--) {
			for (int j = 0; j < i + 1; j++) {
				int left = dp[i + 1][j];
				int right = dp[i + 1][j + 1];
				// 找出这个点从走这两条路径中可得到的最大值
				dp[i][j] = dp[i][j] + Math.max(left, right);
			}
		}
		System.out.println(dp[0][0]);
	}
}

编程31 游戏中的学问

题目描述
大家应该都见过很多人手拉手围着篝火跳舞的场景吧?一般情况下,大家手拉手跳舞总是会围成一个大圈,每个人的左手拉着旁边朋友的右手,右手拉着另一侧朋友的左手。

不过,如果每一个人都随机的拉住两个不同人的手,然后再慢慢散开,事情就变得有趣多了一一此时大家依旧会形成圈,不过却可能会形成多个独立的圈。当然这里我们依然要求一个人的右手只能拉另一个人的左手,反之亦然。

班里一共有 NN 个同学,由 11 到 NN 编号。Will 想知道,究竟有多少种本质不同的拉手方案,使得最终大家散开后恰好形成人个圈呢?

给定两种方案,若存在一个人和他的一只手,满足在这两种方案中,拉着这只手的人的编号不同,则这两种方案本质不同。

输入描述

输入一行包含三个正整数N,K,PN,K,P。

其中,1≤k≤N≤3000,104≤p≤2×1091\leq k\leq N \leq 3000,10^4\leq p\leq2\times10^9。

输出描述

输出一行一个整数,表示本质不同的方案数对 pp 的余数。保证 pp 一定是一个质数。

输入输出样例

示例1

输入

sh 复制代码
3 1 1000000009 

输出

sh 复制代码
2

运行限制

image.png

题解

题目是有每个人的右手,拉住另一个人,求 N 个人形成 k 个圈的可能有多少种。

我们举个例子,A、B、C三个人:
image.png
A 的左手是 C,A 的右手是 B,B 的左手是 A,B 的右手是 C,C 的左手是 B,C 的右手是 A。
image.png
A 的左手是 B,A 的右手是 C,B 的左手是 C,B 的右手是 A,C 的左手是 A,C 的右手是 B,这两种是不同的。

这题可以说是记忆化搜索,也可以说是递推法模型。

这里使用动态规划来解决这题。

定义状态

我们设 dp[i][j]:i:i 个人,j:圈数。表示由 i 个人组成 j 个圈有多少种状态。

找初始状态

题目要求每个人拉住不同的两个人的手,故最少三个人组成 1 个圈。即 dp[3][1]=2。

找状态转移

在考虑 dp[4][1] 时,由于三个人之间,每两人之间有一个空位,共三个空位置,则第四个人加入这个圈时,分别可以插入在这三个空位与其他两个人拉手。而 dp[3][1] 的围成一圈的方案有 2 种,就有 dp[4][1]=3*dp[3][1]=6 种,如下:

sh 复制代码
# 三个人的话,构成的圈有两种
1、1 2 3
2、1 3 2
# 现在第四个人加入,这两个方案每组可以分别抽出三个空位来插入这第四人
# (两个人之间进行插入,注意:首尾是相连的)
1、1 4 2 3
2、1 2 4 3
3、1 2 3 4
4、1 4 3 2
5、1 3 4 2
6、1 3 2 4
# 共上面6种情况
# 第五个人加入
1、1 5 4 2 3
2、1 4 5 2 3
3、1 4 2 5 3
4、1 4 2 3 5
5、1 5 2 4 3
6、1 2 5 4 3
7、1 2 4 5 3
8、1 2 4 3 5
9、1 5 2 3 4
10、1 2 5 3 4
11、1 2 3 5 4
12、1 2 3 4 5
13、1 5 4 3 2
14、1 4 5 3 2
15、1 4 3 5 2
16、1 4 3 2 5
17、1 5 3 4 2
18、1 3 5 4 2
19、1 3 4 5 2
20、1 3 4 2 5
21、1 5 3 2 4
22、1 3 5 2 4
23、1 3 2 5 4
24、1 3 2 4 5
# 共24种组合情况

接着考虑 dp[x+1][y] 和 dp [x][y] 的关系:

假设 x 个人分成了 y 个环后,每个人环的人数有 x1,x2,⋯ ,xyx_1,x_2,\cdots,x_y 人;

  • 对于第一个环有x1x_1人围成一圈,则有x1x_1个空;
  • 对于第二个环有x2x_2人围成一圈,则有x2x_2个空;
  • ...
  • 所有圈的人数加起来,就等于 x1+x2+x3+⋯+xy=xx_1+x_2+x_3+\cdots+x_y=x,所以共有 x 个空,故第 x+1 个人就可以往这 x 个空与其他人拉手形成一个圈。

所以,dp[x + 1][y] = x * dp[x][y],即 dp[i][j] = (i - 1) * dp[i - 1][j].

考虑 dp[6][1] 和 dp[6][2]:

  • 我们知道,至少 3 个人才能组成一个圈。
  • 当第 i 个人加入一个圈时,要在前 i−1i-1 个人抽出两个人,在他们之间拉手,才能组成一个新的圈。
  • 所以原来的 dp[i - 1][j] 变成了 dp[i - 3][j]

由于是从 i−1i-1 个人中抽取 2 个人,我们计算从一个序列中,随机选择两个人的组合情况数量,可以用数学公式 Ci−12C_{i-1}^2 ,这个公式表示从 i−1i-1 个不同的元素中,选取 22 个元素的组合数。

Cnk=n!k!(n−k)!C_n^k=\dfrac{n!}{k!(n-k)!}

故根据公式可以求出 Ci−12=(i−1)(i−2)2C_{i-1}^2=\frac{(i-1)(i-2)}{2}。比如:计算得出从 3 人选取 2 个人来拉手的组合有 3 种,然而已知 3 个人的组合方案有 2 种,故第四个人加入时的组合数有 2×C32=2×3×22=62\times C_{3}^2=2\times \frac{3\times2}{2}=6。

sh 复制代码
# 原先三个人的圈
1 2 3
# 第4人来后,随机抽取两个人,组成新的圈
## 抽取 1 2
1 2 4
1 4 2
## 抽取 1 3
1 3 4
1 4 3
## 抽取 2 3
2 3 4
2 4 3

第五个人加入时,2×C42=2×4×32=122\times C_{4}^2=2\times \frac{4\times3}{2}=12。

sh 复制代码
# 原先四个人的圈
1 2 3 4
# 第5人来后,随机抽取两个人,组成新的圈
## 抽取 1 2
1 2 5
1 5 2
## 抽取 1 3
1 3 5
1 5 3
## 抽取 1 4
1 4 5
1 5 4
## 抽取 2 3
2 3 5
2 5 3
## 抽取 2 4
2 4 5
2 5 4
## 抽取 3 4
3 4 5
3 5 4

那么第 i 个人加入时的组合成三个人一圈的方案有 2×Ci−12=2×(i−1)(i−2)2=(i−1)(i−2)2\times C_{i-1}^2=2\times \frac{(i-1)(i-2)}{2}=(i-1)(i-2)。

所以 dp[i][j + 1] = dp[i - 3][j] * (i - 1) * (i - 2)
即 dp[i][j] = dp[i - 3][j - 1] * (i - 1) * (i - 2)

如:dp[4][1] = dp[3][1] * 3 = 6,四个人组合 1 个圈,即在原来圈的基础上,找到 3 个空位围成 4 人圈。
dp[4][2] = dp[1][1] * 3 * 2 = 0,因为 4 个人拆分成两个圈没有可能性,至少要 6 个人才能围成两个圈。
dp[6][2] = dp[3][1] * 5 * 4 = 40,6 个人围成两个圈的方案数。

总的来说:

java 复制代码
集合划分:
1、加入已有的圈,则圈数 j 不变。
方案数是:(前 i-1 个同学围成 j 个圈的方案数)*(i 加入位置的选择数)
即 f[i-1][j]*(i-1) //i可以加到相邻两个人之间,i-1个人围成的圈一共有i-1个空

2、i 和原有的人中的其中两个组成一个新的圈,则圈数 j 要减一。
方案数是:(前i-3个同学围成j-1个圈的方案数)*(i和任意两个同学围成圈的选择数)*(3个人围成一个圈的方案数)

即 f[i-3][j-1] * (C^2(i-1)) * 2 //(C就是有放回的选择,组合公式,从i-1中选两个数的方案数)
=f[i-3][j-1] * (i-1)(i-2)/2 * 1 * 2
=f[i-3][j-1] * (i-1)(i-2)
java 复制代码
import java.util.Scanner;

// 游戏中的学问
public class Main {

	static int N = 3010;
	static long[][] dp = new long[N][N];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int k = sc.nextInt();
		long p = sc.nextLong();

		dp[3][1] = 2; // 三个人,一圈的方案有两个

		// 第 i 个人加入
		for (int i = 4; i <= n; i++) {
			// 遍历计算每一圈的方案数
			for (int j = 1; 3 * j <= i && j <= k; j++) {
				// 第 i 个人加入时,
				// 分别加入 i -1 个人所组合成的 j 个圈中,所有圈共有 i - 1 个空
				dp[i][j] = dp[i - 1][j] * (i - 1) % p;
				// 还要加上第 i 个人加入时,
				// 形成新的圈的组合情况,至少3个人,才能组合成一个新的一圈,故两个圈最少要有6个人
				dp[i][j] = (dp[i][j] + dp[i - 3][j - 1] * (i - 1) * (i - 2)) % p;
			}
		}

		System.out.print(dp[n][k]);
	}
}

编程32 跳跃

题目描述
小蓝在一个 nn 行 mm 列的方格图中玩一个游戏。

开始时,小蓝站在方格图的左上角,即第 11 行第 11 列。

小蓝可以在方格图上走动,走动时,如果当前在第 rr 行第 cc 列,他不能走到行号比 rr 小的行,也不能走到列号比 cc 小的列。同时,他一步走的直线距离不超过 33。

例如,如果当前小蓝在第 33 行第 55 列,他下一步可以走到第 33 行第 66 列、第 33 行第 77 列、第 33 行第 88 列、第 44 行第 55 列、第 44 行第 66 列、第 44 行第 77 列、第 55 行第 55 列、第 55 行第 66 列、第 66 行第 55 列之一。

小蓝最终要走到第 nn 行第 mm 列。

在图中,有的位置有奖励,走上去即可获得,有的位置有惩罚,走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值,奖励为正,惩罚为负。

小蓝希望,从第 11 行第 11 列走到第 nn 行第 mm 列后,总的权值和最大。请问最大是多少?

输入描述

输入的第一行包含两个整数n,mn,m,表示图的大小。

接下来 nn 行,每行 mm 个整数,表示方格图中每个点的权值。

其中,1≤n,m≤1001\leq n,m\leq100,−104≤权值≤104-10^4\leq\text{权值}\leq10^4。

输出描述

输出一个整数,表示最大权值和。

输入输出样例

示例1

输入

sh 复制代码
3 5
-4 -5 -10 -3 1
7 5 -9 3 -10
10 -2 6 -10 -4

输出

sh 复制代码
15

运行限制

image.png

题解

根据题意,画图好做分析:
image.png
一开始想到的就是 DFS 来解题,这和之前的迷宫等题型很类似,只不过这里每个点可走的路比迷宫的多一些。由于不用走回头路,故不需要使用 vistied 数组来进行标记已访问过的格子。废话不多说,直接上代码。

java 复制代码
import java.util.Scanner;

// 跳跃
public class Main {

	static int n, m;
	static int[][] graph;
	static int[][] dp = new int[101][101];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		graph = new int[n + 3][m + 3];

		// 图的数据
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				graph[i][j] = sc.nextInt();
			}
		}
		dfs(1, 1, 0);
		System.out.print(max);
	}

	static int max = -0x3f3f3f3f; // 注意:这里的权值是负数,故取一个无穷小的值

	// 方向
	static int[][] direction = {
			// 走一步
			{ 1, 0 }, { 0, 1 },
			// 走两步
			{ 2, 0 }, { 1, 1 }, { 0, 2 },
			// 走三步
			{ 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 } };

	/**
	 * 深度优先搜索
	 * 
	 * @param x   当前所在行
	 * @param y   当前所在列
	 * @param sum 当前权值和
	 */
	private static void dfs(int x, int y, int sum) {
		sum += graph[x][y];
		if (x == n && y == m) {
			if (sum > max) {
				max = sum;
			}
			return;
		}
		// 尝试九个不同走法
		for (int i = 0; i < 9; i++) {
			int nextX = x + direction[i][0];
			int nextY = y + direction[i][1];
			if (pd(nextX, nextY)) {
				dfs(nextX, nextY, sum);
			}
		}
	}

	/**
	 * 判断这一步可以走不
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private static boolean pd(int x, int y) {
		if (x < 1 || x > n || y < 1 || y > m)
			return false;
		return true;
	}

}

image.png
试着用 DP 来解决该问题。我们定义一个数组 dp[i][j],记录走到第 i 行,第 j 列的权值和。

但如果我们从起点开始出发,很难判断出当前走哪一步才是下一步它的最优解。

那我们反着来,有九种方式到达下一个点,那我们就记录从当前这个点 graph[i][j] 通过九个方式所能达到的最大权值和。那之后每一个点都会去判断得出它所能到的最大权值。并记录在他自己身上,那么之后返回到达起点时,我们就可以找出起点所能到达的九个路径中权值最大的那条(这个点的权值已经是最优状态,已记录了所有路径的和)。

java 复制代码
import java.util.Scanner;

// 跳跃
public class Main {

	static int n, m;
	static int[][] graph;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		graph = new int[n + 1][m + 1];

		// 图的数据
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				graph[i][j] = sc.nextInt();
			}
		}
		solve();
	}

	// 方向
	static int[][] direction = {
			// 走一步
			{ 1, 0 }, { 0, 1 },
			// 走两步
			{ 2, 0 }, { 1, 1 }, { 0, 2 },
			// 走三步
			{ 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 } };

	static int[][] dp = new int[101][101];

	/**
	 * 动态规划(逆推)
	 */
	private static void solve() {
		dp[n][m] = graph[n][m];
		// 从终点回退
		for (int i = n; i >= 1; i--) {
			for (int j = m; j >= 1; j--) {
				// 终点不处理
				if (i == n && j == m)
					continue;
				int temp = -0x3f3f3f3f;
				// 找出接下来这九步哪一步从 i、j出发时的权值最大
				for (int k = 0; k < 9; k++) {
					int nextX = i + direction[k][0];
					int nextY = j + direction[k][1];
					if (pd(nextX, nextY)) {
						temp = Math.max(dp[nextX][nextY], temp);
					}
				}
				// 找到走到这一步所能找到的最优路径(权值最大的路)
				dp[i][j] = graph[i][j] + temp;
			}
		}
		System.out.print(dp[1][1]);
	}


	/**
	 * 判断这一步可以走不
	 * 
	 * @param x
	 * @param y
	 * @return
	 */
	private static boolean pd(int x, int y) {
		if (x < 1 || x > n || y < 1 || y > m)
			return false;
		return true;
	}

}

编程33 小明的背包1

题目描述

小明有一个容量为 VV 的背包。

这天他去商场购物,商场一共有 NN 种物品,第 ii 种物品的体积为 wiw_i 价值为 viv_i。

小明想知道在购买的物品总体积不超过 VV 的情况下所能获得的最大价值为多少,请你帮他算算。

输入描述

输入第 11 行包含两个正整数 NN,VV,表示商场物品的数量和小明的背包容量。

第 2∼N+12\sim N+1 行包含 22 个正整数 w,vw,v,表示物品的体积和价值。

1≤N≤103,1≤V≤103,1≤wi,vi≤1031\leq N\leq10^3,1\leq V\leq 10^3,1\leq w_i,v_i\leq10^3。

输出描述
输出一行整数表示小明所能获得的最大价值。

输入输出样例

示例1

输入

sh 复制代码
5 20
1 6
2 5
3 8
5 15
3 3 

输出

sh 复制代码
37

运行限制

image.png

题解

这是一道 0/1 背包问题,要么选择,要么不选。每种物品只选 1 件或者 0 件。

java 复制代码
import java.util.*;

// 小明的背包1
public class Main {

	static int[][] dp;

	static int[] c = new int[110]; // 体积
	static int[] w = new int[110]; // 价值

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt(); // n件物品
		int C = sc.nextInt(); // 背包容量
		dp = new int[N + 10][C + 10]; // 二维dp
		for (int i = 1; i <= N; i++) {
			c[i] = sc.nextInt();
			w[i] = sc.nextInt();
		}
		System.out.print(solve(N, C));
	}

	static int N=-0x3f3f3f3f;
	
	/**
	 * 动态规划
	 * 
	 * @param N 物品个数
	 * @param C 背包容量
	 * @return
	 */
	private static int solve(int N, int C) {
		// 初始化
		for (int i = 0; i <= N; i++) {
			for (int j = 0; j <= C; j++) {
				dp[i][j] = 0;
			}
		}
		// 从第一个物品开始往下放进背包,看看怎么放最大
		for (int i = 1; i <= N; i++) {
			// 当前物品的体积
			int curC = c[i];
			// 遍历 0 到 C 每种容量情况
			for (int j = 0; j <= C; j++) {
				// 上一个商品组合的价值
				int lastW = dp[i - 1][j];
				// 当前物品放不下,则存放上一次组合的价值
				if (curC > j) {
					dp[i][j] = lastW;
				} else {
					int m = j - curC; // 存放该物品时剩余的体积
					// 找到上一次存放达到这个体积的最大价值,加入该物品
					int curW = dp[i - 1][m] + w[i];
					// 得到最大值
					dp[i][j] = Math.max(curW, lastW);
				}
			}
		}
		return dp[N][C];
	}
}

编程34 小明的背包2

题目描述

小明有一个容量为 VV 的背包。

这天他去商场购物,商场一共有 NN 种物品,第 ii 种物品的体积为 wiw_i 价值为 viv_i,每种物品都有无限多个。

小明想知道在购买的物品总体积不超过 VV 的情况下所能获得的最大价值为多少,请你帮他算算。

输入描述

输入第 11 行包含两个正整数 NN,VV,表示商场物品的数量和小明的背包容量。

第 2∼N+12\sim N+1 行包含 22 个正整数 w,vw,v,表示物品的体积和价值。

1≤N≤103,1≤V≤103,1≤wi,vi≤1031\leq N\leq10^3,1\leq V\leq 10^3,1\leq w_i,v_i\leq10^3。

输出描述
输出一行整数表示小明所能获得的最大价值。

输入输出样例

示例1

输入

sh 复制代码
5 20
1 6
2 5
3 8
5 15
3 3 

输出

sh 复制代码
120

运行限制

image.png

题解

这题是典型的完全背包问题,但思路其实是和 0/1 背包问题差不的。这是一开始没学习完全背包的解法,按照思路写了下,但有样例不通过。

java 复制代码
import java.util.*;

//小明的背包2
public class Main {

	static int[][] dp = new int[1010][1010];
	static int[] w = new int[1010];
	static int[] v = new int[1010];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt(); // n件物品
		int V = sc.nextInt(); // 背包容量
		for (int i = 1; i <= N; i++) {
			w[i] = sc.nextInt();
			v[i] = sc.nextInt();
		}
		System.out.print(solve(N, V));
	}

	/**
	 * 动态规划
	 * 
	 * @param N 物品个数
	 * @param V 背包容量
	 * @return
	 */
	private static int solve(int N, int V) {
		for (int i = 0; i <= N; i++) {
			for (int j = 0; j <= V; j++) {
				dp[i][j] = 0;
			}
		}
		// 尝试放入第 i 个物品,看看能否放进背包
		for (int i = 1; i <= N; i++) {
			int curW = w[i]; // 物品体积
			int curV = v[i]; // 物品价值
			// 尝试放进每种容量的情况,看看对于这种情况的最大价值
			for (int j = 0; j <= V; j++) {
				// 该物品放不下,则保持原来的最大值
				if (curW > j) {
					dp[i][j] = dp[i - 1][j];
				} else {
					// 当前容量最多可以放进 j / curV 件物品
					for (int k = 1; k <= j / curW; k++) {
						int tempW = curW * k; // 当前所拿的物品体积
						int tempV = curV * k; // 当前所拿物品价值
						// 看看拿 k 件该物品放入背包,与其他物品一起组合放进背包,看看能不能获得更大的价值
						dp[i][j] = Math.max(dp[i][j - tempW] + tempV, dp[i - 1][j]);
					}
				}
			}
		}
		return dp[N][V];
	}
}

image.png
之后学习了完全背包解题思路后,更新的解法,其实与 0/1 背包区别只有一个,就是 0/1 背包只有选择一个 i 和不选择 i 的结果(当前选择 i,或者不选择 i就去上一次该容积的最优解),而完全背包则还有考虑选择多个 i 的情况,所以就不能只取上一次未考虑 i 的情况,这次放入物品 i 时,还得看看之前有考虑选物品 i 的最优解。也就是 dp[i][j-w[i]],而不是 dp[i-1][j-w[i]]。

java 复制代码
import java.util.*;

// 小明的背包2
public class Main {

	static int[][] dp = new int[1010][1010];
	static int[] w = new int[1010];
	static int[] v = new int[1010];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt(); // n件物品
		int V = sc.nextInt(); // 背包容量

		// 初始化
		Arrays.fill(dp[0], 0);

		for (int i = 1; i <= N; i++) {
			w[i] = sc.nextInt();
			v[i] = sc.nextInt();
			// 顺便初始化
			Arrays.fill(dp[i], 0);
		}
		System.out.print(solve(N, V));
	}

	/**
	 * 动态规划
	 * 
	 * @param N 物品个数
	 * @param V 背包容量
	 * @return
	 */
	private static int solve(int N, int V) {
		// 遍历每个物品,尝试放入背包中
		for (int i = 1; i <= N; i++) {
			int curW = w[i]; // 物品体积
			int curV = v[i]; // 物品价值
			// 遍历放进每种背包容量的情况,计算对于这种容量的最优解
			for (int j = 1; j <= V; j++) {
				// 不选择放入物品,则背包的价值与上一次相同
				dp[i][j] = dp[i - 1][j];
				// 如果背包容量足够,选1个或者多个(直接取当前放入 i 后,剩余容积在当时在选择 i 时的最优解)
				if (j >= curW) {
					dp[i][j] = Math.max(dp[i][j], dp[i][j - curW] + curV);
				}
			}
		}
		return dp[N][V];
	}
}

image.png
上述代码中可以看到,每一次尝试存放物品时,只与本次和上一次的结果有关,故可以使用空间压缩,压缩成一维数组,需要注意的是,0/1 背包问题是从大体积开始逐渐处理到小体积背包,因为只与上一次不考虑 i 的结果有关,在计算大容量背包时,依赖于上一次的小容量的最优解(从大到小遍历防止覆盖之前的未考虑 i 时的最优解)。而完全背包问题需看看有考虑 i 的情况,故可以从小到大体积,选择 i 后看看是否能得出比上一次更优的解。

java 复制代码
import java.util.*;

// 小明的背包2
public class Main {

	static int[] dp = new int[1010];
	static int[] w = new int[1010];
	static int[] v = new int[1010];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt(); // n件物品
		int V = sc.nextInt(); // 背包容量

		// 初始化
		Arrays.fill(dp, 0);

		for (int i = 1; i <= N; i++) {
			w[i] = sc.nextInt();
			v[i] = sc.nextInt();
		}
		System.out.print(solve(N, V));
	}

	/**
	 * 动态规划
	 * 
	 * @param N 物品个数
	 * @param V 背包容量
	 * @return
	 */
	private static int solve(int N, int V) {
		// 遍历每个物品,尝试放入背包中
		for (int i = 1; i <= N; i++) {
			int curW = w[i]; // 物品体积
			int curV = v[i]; // 物品价值
			// 开始存放物品,我们希望当前选择i后的结果能被保留
			// 注意从小到大遍历
			for (int j = curW; j <= V; j++) {
				dp[j] = Math.max(dp[j], dp[j - curW] + curV);
			}
		}
		return dp[V];
	}
}

与上一次比较,内存占用少了些
image.png

编程35 小明的背包3

题目描述

小明有一个容量为 VV 的背包。

这天他去商场购物,商场一共有 NN 种物品,第 ii 种物品的体积为 wiw_i 价值为 viv_i,数量为 sis_i。

小明想知道在购买的物品总体积不超过 VV 的情况下所能获得的最大价值为多少,请你帮他算算。

输入描述

输入第 11 行包含两个正整数 NN,VV,表示商场物品的数量和小明的背包容量。

第 2∼N+12\sim N+1 行包含 22 个正整数 w,v,sw,v,s,表示物品的体积和价值。

1≤N≤102,1≤V≤2×102,1≤wi,vi,si≤2×1021\leq N\leq10^2,1\leq V\leq 2\times10^2,1\leq w_i,v_i,s_i\leq2\times10^2。

输出描述
输出一行整数表示小明所能获得的最大价值。

输入输出样例

示例1

输入

sh 复制代码
3 30
1 2 3
4 5 6
7 8 9

输出

sh 复制代码
39

运行限制

image.png

题解

这是一道多重背包的问题,我们可以将每个物品有几件看作是一个新物品,比如苹果有2个(物品 A),苹果有3个(物品 B),那把数量和物品看成整体后,我们就可以当做 0/1 背包问题来解决了。

需要注意的是,0/1 背包问题和多重背包问题的遍历,是从大到小开始遍历的,确保该物品只能被添加一次。而完全背包问题的遍历是从小到大遍历的,每件物品可以重复添加多次。

java 复制代码
import java.util.Arrays;
import java.util.Scanner;

// 小明的背包3
public class Main {
	static int[][] dp;
	static int[] w;
	static int[] v;
	static int[] s;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt(); // n件物品
		int V = sc.nextInt(); // 背包容量

		w = new int[N + 1];
		v = new int[N + 1];
		s = new int[N + 1];
		dp = new int[N + 1][V + 1];

		Arrays.fill(dp[0], 0);
		for (int i = 1; i <= N; i++) {
			w[i] = sc.nextInt();
			v[i] = sc.nextInt();
			s[i] = sc.nextInt();
			// 顺便初始化
			Arrays.fill(dp[i], 0);
		}
		System.out.print(solve(N, V));
	}

	/**
	 * 动态规划
	 * 
	 * @param N 物品个数
	 * @param V 背包容量
	 * @return
	 */
	private static int solve(int N, int V) {
		// 尝试放入物品
		for (int i = 1; i <= N; i++) {
			// 遍历物品数量
			for (int j = 0; j <= s[i]; j++) {
				int curW = j * w[i]; // 当前选择 j 件物品的体积
				int curV = j * v[i]; // 当前选择 j 件物品的价值
				// 把选择 j 件 i物品,看作是一个整体
				// 将其放入背包,这就可以看成 0/1 背包问题了
				// 尝试放入容积为 k 的背包
				// 背包容量(从大到小遍历)确保该物品只被添加一次
				for (int k = V; k >= j * w[i]; k--) {
					// 比较之前有考虑i的情况,得到该容积最优解
					dp[i][k] = Math.max(dp[i - 1][k - curW] + curV, dp[i][k]);
				}
			}
		}
		return dp[N][V];
	}
}

空间压缩成一维。

java 复制代码
import java.util.Arrays;
import java.util.Scanner;

// 小明的背包3
public class Main {
	static int[] dp;
	static int[] w;
	static int[] v;
	static int[] s;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt(); // n件物品
		int V = sc.nextInt(); // 背包容量

		w = new int[N + 1];
		v = new int[N + 1];
		s = new int[N + 1];
		dp = new int[V + 10];

		Arrays.fill(dp, 0);

		for (int i = 1; i <= N; i++) {
			w[i] = sc.nextInt();
			v[i] = sc.nextInt();
			s[i] = sc.nextInt();
		}
		System.out.print(solve(N, V));
	}

	/**
	 * 动态规划
	 * 
	 * @param N 物品个数
	 * @param V 背包容量
	 * @return
	 */
	private static int solve(int N, int V) {
		// 尝试放入物品
		for (int i = 1; i <= N; i++) {
			// 背包容量(从大到小遍历)确保该物品组合只被添加一次
			for (int j = V; j >= w[i]; j--) {
				// 遍历物品数量
				for (int k = 1; k <= s[i] && (j - k * w[i] >= 0); k++) {
					int curW = k * w[i]; // 当前选择 j 件物品的体积
					int curV = k * v[i]; // 当前选择 j 件物品的价值
					// 更新当前容量的背包的最优情况
					dp[j] = Math.max(dp[j], dp[j - curW] + curV);
				}
			}
		}
		return dp[V];
	}
}

编程36 蓝肽子序列

题目描述

L 星球上的生物由蛋蓝质组成,每一种蛋蓝质由一类称为蓝肽的物资首尾连接成一条长链后折叠而成。

生物学家小乔正在研究 L 星球上的蛋蓝质。她拿到两个蛋蓝质的蓝肽序列,想通过这两条蓝肽序列的共同特点来分析两种蛋蓝质的相似性。

具体的,一个蓝肽可以使用 11 至 55 个英文字母表示,其中第一个字母大写,后面的字母小写。一个蛋蓝质的蓝肽序列可以用蓝肽的表示顺序拼接而成。

在一条蓝肽序列中,如果选取其中的一些位置,把这些位置的蓝肽取出,并按照它们在原序列中的位置摆放,则称为这条蓝肽的一个子序列。蓝肽的子序列不一定在原序列中是连续的,中间可能间隔着一些未被取出的蓝肽。

如果第一条蓝肽序列可以取出一个子序列与第二条蓝肽序列中取出的某个子序列相等,则称为一个公共蓝肽子序列。

给定两条蓝肽序列,找出他们最长的那个公共蓝肽子序列的长度。

输入描述

输入两行,每行包含一个字符串,表示一个蓝肽序列。字符串中间没有空格等分隔字符。
其中有,两个字符串的长度均不超过10001000。

输出描述

输出一个整数,表示最长的那个公共蓝肽子序列的长度。

输入输出样例

示例

输入

sh 复制代码
LanQiaoBei
LanTaiXiaoQiao

输出

sh 复制代码
2

运行限制

image.png

题解

这题是 LCS 类型的题目变形,由原来的一个字符或者数字匹配变成了单词匹配。

根据题目要求,首字母大写后紧跟几个小写字母的,就是一个蓝肽子序列。且组成的子序列可能在原串并不连续。

我们可以从这两个字符串中,找出这些子序列并分别存储起来,之后进行比较,如果比较的子序列相等,则进行累加,直到最后两个序列都比较完毕,则可以得到最长子序列的长度。

输入案例的最长子序列:

sh 复制代码
# 先找出子序列
Lan Qiao Bei
Lan Tai Xiao Qiao
# 之后两两比较,累加子序列长度,最终得到的最长子序列为:
LanQiao

是有两个子序列组成,长度为2。下边是代码实现:

java 复制代码
import java.util.*;

// 蓝肽子序列
public class Main {

	static int[][] dp = new int[1001][1001];
	static String str1;
	static String str2;

	// 存放蓝肽子序列
	static String[] a = new String[1001];
	static String[] b = new String[1001];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		str1 = sc.next();
		str2 = sc.next();

		int len1 = str1.length();
		int len2 = str2.length();

		int n = 0; // 记录字符串1的子序列
		int m = 0; // 记录字符串2的子序列

		// 一个蓝肽由1到5个英文字母组成,第一个大写,后面的小写
		for (int i = 0; i < len1;) {
			int c = str1.charAt(i);
			// 找到首个字母大写的位置,是蓝肽子序列的开始
			if (c >= 'A' && c <= 'Z') {
				// 拼接子序列
				a[n] += c;
				i++;
				while (i < len1 && str1.charAt(i) >= 'a' && str1.charAt(i) <= 'z') {
					a[n] += str1.charAt(i);
					i++;
				}
			}
			// 当前一个子序列结束,累计子序列数量
			n++;
		}

		// 一个蓝肽由1到5个英文字母组成,第一个大写,后面的小写
		for (int i = 0; i < len2;) {
			int c = str2.charAt(i);
			// 找到首个字母大写的位置,是蓝肽子序列的开始
			if (c >= 'A' && c <= 'Z') {
				// 拼接子序列
				b[m] += c;
				i++;
				while (i < len2 && str2.charAt(i) >= 'a' && str2.charAt(i) <= 'z') {
					b[m] += str2.charAt(i);
					i++;
				}
			}
			// 当前一个子序列结束,累计子序列数量
			m++;
		}

		dp[0][0] = 0;

		// dp数组用于存储两个字符串的所有可能子序列的最长公共蓝肽子序列的长度
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				// 如果当前两个子序列相等
				if (a[i].equals(b[j])) {
					// 累计公共蓝肽子序列的数量
					dp[i + 1][j + 1] = dp[i][j] + 1;
				} else {
					// 不相等
					// 取出上一次 a 中第 i 个子序列 与 b 中 第 j - 1 个子序列的比较结果
					// 与 a 中的第 i - 1 个子序列,与 b 中的第 j 个子序列的比较结果
					// 然后取较大值,表示最长公共蓝肽子序列的长度
					dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]);
				}
			}
		}
		System.out.print(dp[n][m]);
	}
}

编程37 合唱队形

题目描述

NN 位同学站成一排,音乐老师要请其中的 (N−K)(N-K) 位同学出列,使得剩下的 KK 位同学排成合唱队形。

合唱队形是指这样的一种队形:设 KK 位同学从左到右依次编号为1,2,⋯ ,K1,2,\cdots,K,他们的身高分别为 T1,T2,⋯ ,TKT_1,T_2,\cdots,T_K, 则他们的身高满足 T1<⋯<Ti>Ti+1>⋯>TK(1≤i≤K)T_1<\cdots<T_i>T_{i+1}>\cdots >T_K(1\leq i\leq K)。

你的任务是,已知所有 NN 位同学的身高,计算最少需要几位同学出列,可以使得剩下的同学排成合唱队形。

输入描述

输入两行。

第一行是一个整数 N(2≤N≤100)N(2\leq N\leq 100),表示同学的总数。

第二行有 nn 个整数,用空格分隔,第 ii 个整数 Ti(130≤Ti≤230)T_i(130\leq T_i\leq230) 是第 ii 位同学的身高(厘米)。

输出描述

输出一个整数,就是最少需要几位同学出列。

输入输出样例

示例1

输入

sh 复制代码
8
186 186 150 200 160 130 197 220 

输出

sh 复制代码
4

运行限制

image.png

题解

这题的话,从 N 位同学,抽出最少的同学,使队伍能从低到高,高到低排列(梯度排列),且没有相同身高的,那么就是留下最多的情况,那就可以考虑使用 LIS。

但 LIS 只能处理单调子序列最长,这题不能直接用。

这题是两头低,中间高,那么我们只要找到中间的最高者,即左侧最长子序列与右侧最长子序列的和的最大者,就是留下最多的情况。

找到每个同学为终点的最长递增子序列,即从第 i 个人的左侧,左到右做一遍 LIS。

找到每个同学为起点的最长递增子序列,即从第 i 个人的右侧,右到左做一遍 LIS。

之后不断地尝试让第 i 个同学作为最高者,看看它的左侧和右侧最长递增子序列最多的,就是我们最终的最高者,那么他两个 LIS 的和,就是最多人留下的情况。

java 复制代码
import java.util.Scanner;

// 合唱队形
public class Main {

	static int N; // 人数
	static int[] arr; // 身高
	static int[] dp1; // 存储递增子序列
	static int[] dp2; // 存储递减子序列

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		arr = new int[N];
		dp1 = new int[N];
		dp2 = new int[N];

		for (int i = 0; i < N; i++) {
			arr[i] = sc.nextInt();
			// 初值,每个位置的递增子序列长度为1
			dp1[i] = 1;
			dp2[i] = 1;
		}

		// 186 186 150 200 160 130 197 220
		// 186 186 150 200 160 130 197 220
		// dp1 [1 1 1 2 2 1 3 4]
		// dp2 [3 3 2 3 2 1 1 1]

		// 150 160 170 200 170 160 150
		// dp1 [1 2 3 4 3 2 1]
		// dp2 [1 2 3 4 3 2 1]

		// 进行从左到右的LIS,找出终点为i的最长递增子序列
		// 也就是 第 i 位同学左边的最长子序列
		for (int i = 0; i < N; i++) {
			// 每次与之前的比较,
			for (int j = 0; j < i; j++) {
				// 当前终点位置 i 的身高大于 j 的
				// 且以 j 为终点的最长递增子序列 + i自己本身(1)后大于 i 目前的最长递增子序列
				// 则更新
				if (arr[i] > arr[j] && dp1[j] + 1 > dp1[i]) {
					dp1[i] = dp1[j] + 1;
				}
			}
		}

		// 进行从右到左的LIS,找出起点为i的最长递增子序列
		// 也就是第 i 位 同学右边的最长子序列
		for (int i = N - 1; i >= 0; i--) {
			for (int j = N - 1; j > i; j--) {
				if (arr[i] > arr[j] && dp2[j] + 1 > dp2[i]) {
					dp2[i] = dp2[j] + 1;
				}
			}
		}

		int max = 0;

		for (int i = 0; i < N; i++) {
			// 左右两侧的 LIS 都包含自己一次,故减去一次自己,比如
			// 200的左侧递增为:150 160 170 200
			// 右侧为:200 170 160 150
			// 故减去一次自身
			max = Math.max(max, dp1[i] + dp2[i] - 1);
		}
		// 总人数-留下的最大人数=出列最少的人数
		System.out.print(N - max);
	}
}

编程38 最优包含

题目描述

我们称一个字符串 SS 包含字符串 TT 是指 TT 是 SS 的一个子序列,即可以从字符串 SS 中抽出若干个字符,它们按原来的顺序组合成一个新的字符串与 TT 完全一样。

给定两个字符串 SS 和 TT,请问最少修改 SS 中的多少个字符,能使 SS 包含 TT?

其中,1≤∣T∣≤∣S∣≤10001\leq |T|\leq |S|\leq1000。

输入描述

输入两行,每行一个字符串。

第一行的字符串为 SS,第二行的字符串为 TT。

两个字符串均非空而且只包含大写英文字母。

输出描述

输出一个整数,表示答案。

输入输出样例

示例1

输入

sh 复制代码
ABCDEABCD
XAABZ

输出

sh 复制代码
3

运行限制
image.png

题解

这题是线性 DP 中比较经典的题目。

这个类型就做编辑距离,可以通过 DFS 解决,也可以通过 DP 解决。

DP 的时间复杂度低。

这里先了解下编辑距离。

编辑距离为两个字符串,aa 和 bb 通过多少次变换,使得 aa 变成 bb。
我们可以做出 33 种操作。

  1. 删除操作,将 a[i]a[i] 从 aa 中移除
  2. 插入操作,在 a[i]a[i] 后加上 b[j]b[j]
  3. 替换操作,将 a[i]a[i] 修改为 b[j]b[j]

编辑距离的状态转移类似 LCS,但有有很大的差别。

初始状态,i=j=0i=j=0,都在字符串的开头。

然后开始判断 a[i]=?b[j]a[i]=?b[j]

  • 如果相同,那么就不需要修改,所以 dp[i+1][j+1]=dp[i][j]dp[i+1][j+1]=dp[i][j]
    所以在 a[i−1]a[i-1] 等于 b[j−1]b[j-1] 时,dp[i][j]dp[i][j] 这个状态由 dp[i−1][j−1]dp[i-1][j-1] 转移而来。
    dp[i][j]=dp[i−1][j−1]dp[i][j]=dp[i-1][j-1]
  • 如果不同,那就需要进行三种可能的操作
    1. 修改操作:
      a[i]a[i] 修改为 b[j]b[j],因为编辑了一次,所以 +1+1
      dp[i+1][j+1]=dp[i][j]+1dp[i+1][j+1]=dp[i][j]+1
      所以在 a[i−1]a[i-1] 不等于 b[j−1]b[j-1] 时,dp[i][j]dp[i][j] 这个状态由 dp[i−1][j−1]dp[i-1][j-1] 转移而来。
      dp[i][j]=dp[i−1][j−1]dp[i][j]=dp[i-1][j-1]
    2. 删除操作,直接把 a[i]a[i] 删除,此时转移到 dp[i][j+1]dp[i][j+1],因为 a[i]a[i] 被删除,但是下一个字符到了 a[i]a[i] 的位置,而对应比较的位置到了 b[j+1]b[j+1]。
      所以此时状态转移到了 dp[i][j+1]dp[i][j+1]
      dp[i][j+1]=dp[i][j]+1dp[i][j+1]=dp[i][j]+1
      因为编辑了一次,所以 +1+1
      所以在 a[i−1]a[i-1] 不等于 b[j−1]b[j-1] 时,dp[i][j]dp[i][j] 就有可能通过 dp[i−1][j]dp[i-1][j]
      转移而来。
    3. 插入操作,在 a[i]a[i] 后添加一个 b[j]b[j],那么此时 a[i+1]a[i+1] 和 b[j]b[j] 对应,因为加了一个字符就变成了 a[i+1]a[i+1],而且跟 b[j]b[j] 对应,那么下一个状态转移到了 dp[i+1][j]dp[i+1][j]
      dp[i+1][j]=dp[i][j]+1dp[i+1][j]=dp[i][j]+1
      此时状态转移到了 dp[i+1][j]=dp[i][j]+1dp[i+1][j]=dp[i][j]+1
      因为编辑了一次,所以 +1+1
      所以在 a[i−1]a[i-1] 不等于 b[j−1]b[j-1] 时,dp[i][j]dp[i][j] 就有可能通过 dp[i][j−1]dp[i][j-1] 转移而来。

那么不同时,我们选择他们的最小值即可。

模板如下:

java 复制代码
import java.util.Scanner;

public class Main {
    public static int dp[][];

    // 初始化动态规划数组
    public static void init(int n, int m) {
        dp = new int[n + 1][m + 1];
        // 将 dp 数组的第一列都初始化为 0,
        // 因为当目标字符串为空时,无论原始字符串如何变化,最小编辑距离为 0
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 0;
        }
        // 将 dp 数组的第一行除了第一个元素外都初始化为一个较大的数,
        // 因为当目标字符串不为空时,每个位置的字符默认初始化一个最大的编辑距离
        for (int j = 1; j <= m; j++) {
            dp[0][j] = 99999;
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        String s = in.nextLine();
        String t = in.nextLine();

        int n = s.length();
        int m = t.length();

        // 初始化动态规划数组
        init(n, m);

        // 动态规划求解最小编辑距离
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                char a = s.charAt(i - 1);
                char b = t.charAt(j - 1);
                // 如果在当前位置的字符相等,则不需要编辑,直接取上一次未考虑当前字符的最优解
                if (a == b) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    // 如果当前位置的字符不相等,则取以下三种操作的最小值,然后加上 1(表示本次操作):
                    // 1. 将 s 的前 i-1 个字符替换为 t 的前 j-1 个字符,即 dp[i - 1][j - 1]
                    // 2. 将 s 的前 i-1 个字符变为 t 的前 j 个字符,即 dp[i - 1][j]
                    // 3. 将 s 的前 i 个字符变为 t 的前 j-1 个字符,即 dp[i][j - 1]
                    dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1])) + 1;
                }
            }
        }

        // 输出最终的最小编辑距离
        System.out.println(dp[n][m]);
    }

    public static int min(int a, int b) {
        return Math.min(a, b);
    }
}

这题解法的话,理解上面的思路后,由于题目是包含关系,与原来的编辑问题不一样,不是相等关系,所以当 S 多于 T 时,不需要进行删减操作。

java 复制代码
import java.util.*;

// 最优包含
public class Main {

	static int[][] dp;

	private static void init(int n, int m) {
		dp = new int[n + 1][m + 1];
		for (int i = 0; i <= n; i++) {
			// 将 dp 的第一列都初始化为 0
			// 当目标字符串为空时,无论原始字符串如何变化,最小编辑距离为0
			dp[i][0] = 0;
		}
		for (int j = 1; j <= m; j++) {
			// 将 dp 的第一行除了第一个元素外都初始化为一个较大的数
			// 当目标字符串不为空时,每个位置的字符默认初始化一个最大的编辑距离
			dp[0][j] = 99999;
		}
	}

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		String t = sc.next();

		int n = s.length();
		int m = t.length();

		// 初始化状态
		init(n, m);

		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				char a = s.charAt(i - 1);
				char b = t.charAt(j - 1);
				// 如果在当前位置的字符相等,则不需要编辑,直接取上一次未考虑当前字符的最优解
				if (a == b) {
					dp[i][j] = dp[i - 1][j - 1];
				} else {
					// 如果当前位置的字符不相等,则取以下两种操作的最小值,然后加上 1(表示本次操作):
					// 1. 将 s 的前 i-1 个字符替换为 t 的前 j-1 个字符,即 dp[i - 1][j - 1]
					// 2. 将 s 的前 i-1 个字符变为 t 的前 j 个字符,即 dp[i - 1][j]
					dp[i][j] = Math.min(dp[i - 1][j - 1] + 1, dp[i - 1][j]);
				}
			}
		}

		System.out.println(dp[n][m]);
	}
}

编程39 路径

本题为填空题,只需要算出结果后,在代码中使用输出语句将所填结果输出即可。

小蓝学习了最短路径之后特别高兴,他定义了一个特别的图,希望找到图中的最短路径。

小蓝的图由 2021 个结点组成,依次编号 1 至 2021。

对于两个不同的结点 a,b,如果 a 和 b 的差的绝对值大于 21,则两个结点之间没有边相连;如果 a 和 b 的差的绝对值小于等于 21,则两个点之间有一条长度为 a 和 b 的最小公倍数的无向边相连。

例如:结点 1 和结点 23 之间没有边相连;结点 3 和结点 24 之间有一条无向边,长度为24;结点 15 和结点 25 之间有一条无向边,长度为 75。

请计算,结点 1 和结点 2021 之间的最短路径长度是多少。

提示:建议使用计算机编程解决问题。

运行限制

image.png

题解

这题的话求最短路径可以使用 dijkstra、floyd 等最短路径算法求解,但也可以使用动态规划求解。

我们根据题意知道 a 到 b 之间的权值为他们的最小公倍数,且它们之间差的绝对值小于等于21,它们才能相连,换句话说,我们超过的部分,则需要中转才能到达。

那我们要求出 1 ~ i 的最短路径,可以求出 i-21 ~ i-1 到 i 的权值,然后计算让 1 通过这些点中转到 i 的路径哪个最短即可。

java 复制代码
import java.util.Arrays;

public class Main {

	// 最大公约数
	private static int gcd(int a, int b) {
		return a % b == 0 ? b : gcd(b, a % b);
	}

	// 最小公倍数
	private static int lcm(int a, int b) {
		return a * b / gcd(a, b);
	}

	static int[] dp = new int[2022];

	public static void main(String[] args) {
		// 初始为0,代表 1 到 i 的最短距离未更新
		Arrays.fill(dp, 0);

		// 1到22之间最小公倍数为本身
		for (int i = 1; i <= 22; i++) {
			// 记录 1 到 i之间的最短路径
			dp[i] = i;
		}

		// 计算 1 到(23~2021)之间的最短路径
		for (int i = 23; i <= 2021; i++) {
			for (int j = i - 21; j < i; j++) {
				// 求出 i-21 到 i 每个路径的最小公倍数
				int minlcm = lcm(i, j);
				// 看看 1 从(i-21 ~ i-1)中哪个点转到 i 的路径最短
				// 计算当前从 1 中转 i的路径,如果路径比之前的短,则更新
				// 或者 i 的最短路径为赋初值,则更新
				if (dp[i] > dp[j] + minlcm || dp[i] == 0) {
					dp[i] = dp[j] + minlcm;
				}
			}
		}
		System.out.println(dp[2021]);
	}

}

使用 floyd 的解法,我们可以先计算出不经过中间节点的两点之间的权值,进行初始化,之后再通过 floyd 算法即可求出最短路径了。当然时间复杂度很高,这里是填空题,就可以直接这样做。

java 复制代码
import java.util.Arrays;

// 路径
public class Main {

	// 最大公约数
	private static int gcd(int a, int b) {
		return a % b == 0 ? b : gcd(b, a % b);
	}

	// 最小公倍数
	private static int lcm(int a, int b) {
		return a * b / gcd(a, b);
	}

	public static void main(String[] args) {
		floyd();
	}

	static int[][] dp = new int[2022][2022];
	static final int INF = 0x3f3f3f3f;

	/**
	 * 弗洛伊德算法
	 */
	private static void floyd() {
		// 先计算好每个数字之间的权值
		for (int i = 1; i <= 2021; i++) {
			for (int j = 1; j <= 2021; j++) {
				if (i == j) {
					dp[i][j] = 0;
				} else if (Math.abs(i - j) > 21) {
					// i 不能直接到达 j
					dp[i][j] = dp[j][i] = INF;
				} else {
					// 计算最小公倍数为他们的权值和
					dp[i][j] = lcm(i, j);
				}
			}
		}
		// floyd算法
		for (int k = 1; k <= 2021; k++) {
			for (int i = 1; i <= 2021; i++) {
				for (int j = 1; j <= 2021; j++) {
					// k相当于中转节点,比较经过 k节点的路径是否比原来的更优
					dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k][j]);
				}
			}
		}
		System.out.println(dp1[1][2021]);
	}
}

这里我再用 dijkstra 写一遍。

java 复制代码
import java.util.*;

// 路径
public class Main {

	// 最大公约数
	private static int gcd(int a, int b) {
		return a % b == 0 ? b : gcd(b, a % b);
	}

	// 最小公倍数
	private static int lcm(int a, int b) {
		return a * b / gcd(a, b);
	}

	public static void main(String[] args) {
		dijkstra();
	}

	// 边
	private static class Edge {
		int from, to;
		long w;

		Edge(int a, int b, long w) {
			this.from = a;
			this.to = b;
			this.w = w;
		}
	}

	private static class SNode implements Comparable<SNode> {
		int id;
		long n_dist;

		SNode(int id, long n_dist) {
			this.id = id;
			this.n_dist = n_dist;
		}

		@Override
		public int compareTo(SNode o) {
			return Long.compare(this.n_dist, o.n_dist);
		}
	}

	static List<Edge>[] e = new ArrayList[2022];
	static long[] dist = new long[2022];
	static final long INF = 0x3f3f3f3f3f3fL;
	static boolean[] vis = new boolean[2022];

	/**
	 * 迪杰斯特拉
	 */
	private static void dijkstra() {
		for (int i = 1; i <= 2021; i++) {
			e[i] = new ArrayList<>();
		}
		// 先初始化得到边
		for (int i = 1; i <= 2021; i++) {
			for (int j = 1; j <= 2021; j++) {
				if (Math.abs(i - j) > 21) {
					continue;
				}
				long w = 0;
				if (i != j) {
					w = lcm(i, j);
				}
				Edge edge = new Edge(i, j, w);
				e[i].add(edge);
			}
		}

		Arrays.fill(dist, INF);
		dist[1] = 0;
		// 优先队列
		PriorityQueue<SNode> queue = new PriorityQueue<>();
		queue.add(new SNode(1, dist[1]));

		while (!queue.isEmpty()) {
			SNode node = queue.poll();
			// 已经访问过,则不处理
			if (vis[node.id]) {
				continue;
			}
			vis[node.id] = true;
			// 访问邻接节点
			for (Edge edge : e[node.id]) {
				int to = edge.to;
				long w = edge.w;
				// 已经访问过,则不处理
				if (vis[to]) {
					continue;
				}
				// 如果根据节点 node 到达 to 比之前的路径更优,则更新
				if (dist[to] > node.n_dist + w) {
					dist[to] = node.n_dist + w;
					queue.add(new SNode(to, dist[to]));
				}
			}
		}
		System.out.println(dist[2021]);
	}
}

11. 图论入门

图

图的基本概念

图:由点(node,或者 vertex)和连接点的边(edge)组成。图是点和边构成的网。

树:特殊的图

树,即连通无环图树的结点从根开始,层层扩展子树,是一种层次关系,这种层次关系,保证了树上不会出现环路。两点之间的路径:有且仅有一条路径。最近公共祖先。

图的种类

(1)无向无权图,边没有权值、没有方向;
(2)有向无权图,边有方向、无权值;
(3)加权无向图,边有权值,但没有方向;
(4)加权有向图;
(5)有向无环图(Directed Acyclic Graph, DAG)。

图算法的时间分析

图算法的复杂度和边的数量 E、点的数量 V 相关。O(V+E)O(V+E):几乎是图问题中能达到的最好程度。

O(Vlog⁡E)O(V\log E)、O(Elog⁡V)O(E\log V):很好的算法。O(V2)O(V^2)、O(E2)O(E^2) 或更高:不算是好的算法。

图的存储

能快速访问:图的存储,能让程序很快定位结点 u 和 v 的边(u,v)。

  • 数组存边:简单、空间使用最少;无法快递定位
  • 邻接矩阵:简单、空间使用最大;定位最快 dis[a][b]
  • 邻接表:空间很少,定位较快
  • 链式前向星:空间更少,定位较快

注:存储方式跟题目相匹配,占用空间少定位快也不一定是问题的最优存储方式。

数组存边

优点:简单、最省空间。缺点:无法定位某条边。应用:bellman-ford 算法、最小生成树的 kruskal 算法

java 复制代码
//Java实现
class Edge { int from; int to; int dis;

    public Edge(int from, int to, int dis) {
        this.from = from;
        this.to = to;
        this.dis = dis;
    }

}

Edge[] e = new Edge[M];

Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();

for (int i = 0; i < m; ++i)
{
    int from = sc.nextInt();
    int to = sc.nextInt();
    int dis = sc.nextInt();
    e[i] = new Edge(from, to, dis);
}

邻接矩阵

二维数组:graph[NUM][NUM]graph[NUM][NUM] 无向图:graph[i][j]=graph[j][i]graph[i][j]=graph[j][i]。有向图:graph[i][j]≠graph[j][i]graph[i][j]\ne graph[j][i] 分团。权值: graph[i][j]graph[i][j] 存结点 ii 到 jj 的边的权值。例如 graph[1][2]=3graph[1][2]=3,graph[2][1]=5graph[2][1]=5等等。用 graph[i][j]=INFgraph[i][j]=INF 表示ii ,jj之间无边。

优点:

  • 适合稠密图;
  • 编码非常简短;
  • 对边的存储、查询、更新等操作又快又简单。
    缺点:
  • 存储复杂度 O(V2)O(V^2) 太高。V=10000时,空间 100M。
  • 不能存储重边。

邻接表和链式前向星

邻接表(指针或数组下标)和链式前向星(容器模拟)的思路一样,只是表达方式不同。
image.png

java 复制代码
static class Edge {
    int from, to;
    long w;

    Edge(int a, int b, long c) {
        from = a;
        to = b;
        w = c;
    }
}
static ArrayList<Edge>[] e = new ArrayList[N];

最短路问题

最广为人知的图论问题就是最短路径问题。

简单图的最短路径

  • 树上的路径:任意 22 点之间

只有一条路径

  • 所有边长都为 11 的图:用 BFS 搜最短路径,复杂度 O(n+m)O(n+m)

普通图的最短路径

  • 边长:不一定等于 11,而且可能为负数
  • 算法:Floyd、 Dijkstra、 SPFA 等,各有应用场景,不可互相替代

最短路算法比较

image.png
什么算法也不能解决存在负环图的最短路的问题!最多是判断是否存在,或者找到负环。

网站推荐:https://csacademy.com/app/graph_editor/?tdsourcetag=s_pctim_aiomsg
image.png

Floyd 算法(弗洛伊德算法)

  • 最简单的最短路径算法,代码仅有4行
  • 存图:最简单的矩阵存图
  • 易懂,比暴力的搜索更简单易懂。
  • 效率不高,不能用于大图在某些场景下有自己的优势,难以替代。能做传递闭包问题(离散数学)
模板
java 复制代码
for(int k=1; k<=n; k++)         //floyd的三重循环
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)      // k循环在i、j循环外面
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);

FLoyd 算法:多源最短路算法,一次计算能得到图中每一对结点之间(多对多)的最短路径。

Dijkstra、Bellman-Ford、SPFA算法:单源最短路径算法 (Single source shortest path algorithm),一次计算能得到一个起点到其他所有点(一对多)的最短路径。

在截止目前的蓝桥杯大赛中,Floyd 算法是最常见的最短路径算法。以上统计包括国赛和省赛,所以另外两种仍然要进行学习。

Floyd 算法思想:动态规划
image.png

特点

  • 在一次计算后求得所有结点之间的最短距离。
  • 代码极其简单,是最简单的最短路算法。
  • 效率低下,计算复杂度是 O(m3)O(m^3),只能用于 n<300n<300 的小规模的图。
  • 存图用邻接矩阵 dp[][] 。因为 Floyd 算法计算的结果是所有点对之间的最短路,本身就需要 n^2 的空间,用矩阵存储最合适。
  • 能判断负圈。负圈:若图中有权值为负的边,某个经过这个负边的环路,所有边长相加的总长度也是负数,这就是负圈。在这个负圈上每绕一圈,总长度就更小,从而陷入在负圈上兜圈子的死循环。Floyd 算法很容易判断负圈,只要在算法运行过程出现任意一个 dp[i][j] < 0 就说明有负圈。因为 dp[][] 是从 i 出发,经过其他中转点绕一圈回到自己的最短路径,如果小于零,就存在负圈。

Dijkstra 算法(迪杰斯特拉算法)

  • Dikstra:单源最短路径问题。
  • 优点:非常高效而且稳定。
  • 缺点:只能处理不含有负权边的图。
  • 思路:贪心思想+优先队列。

算法思想

Dijkstra 算法算是贪心思想实现的,首先把起点到所有点的距离存下来找个最短的,然后松弛一次再找出最短的,所谓的松弛操作就是,遍历一遍看通过刚刚找到的距离最短的点作为中转站会不会更近,如果更近了就更新距离,这样把所有的点找遍之后就存下了起点到其他所有点的最短距离。

为什么是每次都是找最小的?

因为最小边的不会被其它的点松弛,只有可能最小边去松弛别人。如果存在一个点 KK 能够松弛 abab 的话那么一定有 akak 距离加上 kbkb 的距离小于 abab,已知 abab 最短,所以不存在 ak+kb<abak + kb < ab。

Dijkstra 算法应用了贪心法的思想,即“抄近路走,肯定能找到最短路径”。

算法高效稳定:

  • Dijkstra 的每次迭代,只需要检查上次已经确定最短路径的那些结点的邻居,检查范围很小,算法是高效的;
  • 每次迭代,都能得到至少一个结点的最短路径,算法是稳定的

优先队列实现:

  • 每次往队列中放新数据时,按从小到大的顺序放,采用小顶堆的方式,复杂度是 O(log⁡n)O(\log n),保证最小的数总在最前面;
  • 找最小值,直接取 B 的第一个数,复杂度是 O(1)O(1)。
  • 复杂度:用优先队列时,Dijkstra 算法的复杂度是 O(mlog⁡n)O(m\log n),是最高效的最短路算法。

维护两个集合:已确定最短路径的结点集合 A、这些结点向外扩散的邻居结点集合 B。

  1. 把起点 s 放到 A 中,把 s 所有的邻居放到 B 中。此时,邻居到 s 的距离就是直连距离。
  2. 从 B 中找出距离起点 s 最短的结点 u,放到 A 中。
  3. 把 u 所有的新邻居放到 B 中。显然,u 的每一条边都连接了一个邻居,每个新邻居都要加进去。其中 u 的一个新邻居 v,它到 s 的距离 dis(s, v) 等于 dis(s, u) + dis(u, v)。
  4. 重复(2)、(3),直到 B 为空时,结束。

Dikstra 的局限性是边的权值不能为负数:

Dikstra 基于 BFS,计算过程是从起点 s 逐步往外扩散的过程,每扩散一次就用贪心得到到一个点的最短路。扩散要求路径越来越长,如果遇到一个负权边,会导致路径变短,使扩散失效。

模板
java 复制代码
import java.util.*;
import java.io.*;

public class Main {
    static final long INF = 0x3f3f3f3f3f3f3f3fL;
    static final int N = 300005;
    static ArrayList<Edge>[] e = new ArrayList[N];
    static int n, m;
    static int[] pre = new int[N];
    static long[] dis = new long[N];
    static boolean[] done = new boolean[N];

    static class Edge {
        int from, to;
        long w;

        Edge(int a, int b, long c) {
            from = a;
            to = b;
            w = c;
        }
    }

    static class SNode implements Comparable<SNode> {
        int id;
        long n_dis;

        SNode(int b, long c) {
            id = b;
            n_dis = c;
        }

        public int compareTo(SNode o) {
            return Long.compare(n_dis, o.n_dis);
        }
    }

    static void printPath(int s, int t) {
        if (s == t) {
            System.out.print(s + " ");
            return;
        }
        printPath(s, pre[t]);
        System.out.print(t + " ");
    }

    static void dijkstra() {
        int s = 1;
        PriorityQueue<SNode> Q = new PriorityQueue<>();
        Arrays.fill(dis, INF);
        dis[s] = 0;
        Q.offer(new SNode(s, dis[s]));
        while (!Q.isEmpty()) {
            SNode u = Q.poll();
            if (done[u.id])
                continue;
            done[u.id] = true;
            for (Edge y : e[u.id]) {
                if (done[y.to])
                    continue;
                if (dis[y.to] > y.w + u.n_dis) {
                    dis[y.to] = y.w + u.n_dis;
                    Q.offer(new SNode(y.to, dis[y.to]));
                    pre[y.to] = u.id;
                }
            }
        }
        // printPath(s, n);
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());
        for (int i = 1; i <= n; i++)
            e[i] = new ArrayList<>();
        for (int i = 1; i <= m; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            long w = Long.parseLong(st.nextToken());
            e[u].add(new Edge(u, v, w));
            // e[v].add(new Edge(v, u, w)); //本题是单向道路
        }
        dijkstra();
        for (int i = 1; i <= n; i++) {
            if (dis[i] >= INF)
                System.out.print("-1 ");
            else
                System.out.print(dis[i] + " ");
        }
    }
}

Bellman-Ford 算法(贝尔曼-福特算法)

BFS 的扩散思想,每个人都去问自己的相邻节点到 S 点的距离最近是多少。

第一轮至少有一个点得到了到 S 的最短距离,即与 S 相邻的节点,标记为 T1

重复以上操作,那么必然至少又有一个节点找到了与 S 的最短距离,即与 T1 相邻的节点,标记为 T2

一共需要几轮操作?

每一轮操作,都至少有一个新的结点得到了到 S 的最短路径。所以,最多只需要 n 轮操作,就能完成 n 个结点。在每一轮操作中,需要检查所有 m 个边,更新最短距离。

Bellman-Ford 算法的复杂度:O(nm)。

Bellman-Ford 能判断负圈:

没有负圈时,只需要 n 轮就结束。

如果超过 n 轮,最短路径还有变化,那么肯定有负圈。

SPFA 算法

队列优化版的 Bellman-Ford

SPFA = 队列处理 + Belliman-Ford。

Bellman-Ford 算法有很多低效或无效的操作。其核心内容,是在每一轮操作中,更新所有结点到起点 S 的最短距离。计算和调整一个结点 U 到 S 的最短距离后,如果紧接着调整 U 的邻居结点,这些邻居肯定有新的计算结果;而如果漫无目的地计算不与 U 相邻的结点,很可能毫无变化,所以这些操作是低效的。

改进: 计算结点 U 之后,下一步只计算和调整它的邻居,能加快收敛的过程。这些步骤用队列进行操作,这就是 SPFA。

  1. 起点 S 入队,计算它所有邻居到 S 的最短距离。把 S 出队,状态有更新的邻居入队,没更新的不入队。
  2. 现在队列的头部是 S 的一个邻居 U。弹出 U,更新它所有邻居的状态,把其中有状态变化的邻居入队列。
  3. 继续以上过程,直到队列空。这也意味着,所有结点的状态都不再更新。最后的状态就是到起点 S 的最短路径。

弹出 U 之后,在后面的计算中,U 可能会再次更新状态(后来发现,U 借道别的结点去 S,路更近)。所以,U 可能需要重新入队列。有可能只有很少结点重新进入队列,也有可能很多。这取决于图的特征。

所以,SPFA 是不稳定的,所以根据题目的类型,我们要选择合适的算法。

模板
java 复制代码
import java.util.*;

public class Main {
    static final long INF = 0x3f3f3f3f3f3f3f3fL;
    static final int N = 5010;

    static long[] dist = new long[N];
    static int[] inq = new int[N];
    static List<edge>[] e = new ArrayList[N];

    static class edge {
        int to;
        long w;

        public edge(int tt, long ww) {
            to = tt;
            w = ww;
        }
    }

    static void spfa(int s) {
        Arrays.fill(dist, INF);
        dist[s] = 0;
        Queue<Integer> q = new LinkedList<>();
        q.add(s);
        inq[s] = 1;
        while (!q.isEmpty()) {
            int u = q.poll();
            inq[u] = 0;
            if (dist[u] == INF) continue;
            for (int i = 0; i < e[u].size(); i++) {
                int v = e[u].get(i).to;
                long w = e[u].get(i).w;
                if (dist[v] > dist[u] + w) {
                    dist[v] = dist[u] + w;
                    if (inq[v] == 0) {
                        q.add(v);
                        inq[v] = 1;
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int s = in.nextInt();
        for (int i = 1; i <= n; i++) {
            e[i] = new ArrayList<>();
        }
        for (int i = 1; i <= m; i++) {
            int u = in.nextInt();
            int v = in.nextInt();
            long w = in.nextLong();
            e[u].add(new edge(v, w));
        }
        spfa(s);
        for (int i = 1; i <= n; i++) {
            if (dist[i] == INF) System.out.print("-1 ");
            else System.out.print(dist[i] + " ");
        }
    }
}

总结

单源最短路
(1)当权值为非负时,用 Dijkstra。
(2)当权值有负值,且没有负圈,则用 SPFA。 SPFA 能检测负圈,但是不能输出负圈。
(3)当权值有负值,而且可能存在负圈需要输出,则用 BellmanFord。能够检测并输出负圈。
多源最短路使用 Floyd。

最小生成树

在无向图中,连通而且不含有圈 (环路) 的图,称为树。最小生成树 MST:一个有 n 个结点的连通图的生成树是原图的极小连通子图,包含原图中的所有 n 个结点,并且边的权值之和最小。

Prim 算法(普里姆算法)

对点进行贪心操作:“最近的邻居一定在 MST 上”。从任意一个点 u 开始,把距离它最近的点 v 加入到 MST 中;下一步,把距离 {u,y} 最近的点 w 加入到 MST 中;继续这个过程,直到所有点都在 MST 中。

模板
java 复制代码
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

	// 定义常量 INF 表示无穷大
	private static final int INF = 0x3f3f3f3f;
	// 定义常量 MAXN 表示顶点的最大数量
	private static final int MAXN = 1005;

	// 存储与顶点 i 最近的结点编号(边权值最小)
	private static int[] closest = new int[MAXN];
	// 存储已经形成的生成树中某个顶点到 i 的最小权值
	private static int[] lowcost = new int[MAXN];

	// 定义二维数组存储图的边权值
	private static int[][] G = new int[MAXN][MAXN];
	private static int m; // 顶点数量

	// 定义列表存储 Prim 算法中生成树的边权值
	private static List<Integer> demo = new ArrayList<>();

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 读取顶点数量 m 和边的数量 n
		m = sc.nextInt();
		int n = sc.nextInt();

		// 读取每条边的起点、终点和权值,并存储到二维数组 G 中
		for (int i = 0; i < n; ++i) {
			int a = sc.nextInt();
			int b = sc.nextInt();
			int c = sc.nextInt();
			G[b][a] = G[a][b] = c;
		}

		// 调用 prim 方法求解最小生成树的权值并输出
		System.out.println(prim());

		// 输出存储在 demo 中的边权值
		for (int i = 0; i < m - 1; i++) {
			System.out.print(demo.get(i) + " ");
		}
	}

	// Prim 算法实现
	private static int prim() {
		// 初始化数组 lowcost 和 closest
		for (int i = 0; i < m; i++) {
			// 存储已经形成的生成树中某个顶点到 i 的最小权值
			// 默认无穷大
			lowcost[i] = INF;
			// 存储与顶点 i 最近的结点编号
			closest[i] = 0;
		}

		// 将第一个顶点加入生成树中,标记为 -1,表示在集合 U 中
		closest[0] = -1;

		int num = 0; // 处理第几条边
		int ans = 0; // 最小生成树的总权值
		int e = 0; // e 为最新加入最小生成树的的点

		// 每次加入一条边,直到加入 m-1 条边为止
		// (最小生成树,那总边数是节点数-1)
		while (num < m - 1) {
			int min_w = INF; // 当前找到的边的最小权值
			int min_num = -1; // 当前找到的最小权值的节点编号

			// 找到当前集合 U 中与集合 V 中最近的顶点
			for (int i = 0; i < m; i++) {
				// 如果 i 已经加入最小生成树,则不处理
				if (closest[i] != -1) {
					// 找到 e 与 i 的边的权值
					int temp = G[e][i];
					// 如果当前边的最短路径比之前最小生成树到 i 的最短路径小,则更新
					if (temp < lowcost[i]) {
						// 更新最小生成树到节点 i 的最短路径为 temp
						lowcost[i] = temp;
						// 更新 i 最近的(权值最小的邻接点) 为 e
						closest[i] = e;
					}
					// 如果当前边的权值,比之前记录的权值小,则更新
					if (lowcost[i] < min_w) {
						min_num = i; // 更新 e 最近节点的编号
						min_w = lowcost[min_num]; // 更新当前的最小权值
					}
				}
			}
			// 将找到的最小权值加入 demo 中
			ans += min_w;
			// 用于之后打印与每个顶点相邻的边的最小权值
			demo.add(min_w);
			// 下次从该顶点找到权值最小的边的节点
			e = min_num;
			// 将找到的顶点标记为已加入生成树的状态,即在集合 U 中
			closest[e] = -1;
			num++;
		}
		// 返回最小生成树的总权值
		return ans;
	}

}

Kruskal 算法(克鲁斯卡尔算法)

对边进行贪心操作:“最短的边一定在 MST 上”。从最短的边开始,把它加入到 MST 中;在剩下的边中找最短的边,加入到 MST 中;继续这个过程,直到所有点都在 MST 中。

kruskal 算法的2个关键技术:

(1)对边进行排序。
(2)判断圈,即处理连通性问题。这个问题用并查集简单而高效,并查集是 kruskal 算法的实现基础。

初始时最小生成树 MST 为空。开始的时候,每个点属于独立的集。

按边长从小到大进行边的遍历操作:

尝试将最小边加入最小生成树:

  • 如果边的两个端点属于同一个集合,就说明这两个点已经被加入最小生成树。则不能将边加入,否则就会生成一个环。
  • 如果两个端点不属于同一个集合,就说明该点还未纳入最小生成树,此边可以加入。

重复上述操作,直到加入 n-1 条边。

kruskal 算法的复杂度包括两部分:对边的排序 O(Elog⁡E)O(E\log E),并查集的操作 O(E)O(E),一共是 O(Elog⁡E+E)O(E\log E + E),约等于 O(Elog⁡E)O(E\log E),时间主要花在排序上。

如果图的边很多,kruskal 的复杂度要差一些。kruskal 适用于稀疏图,prim 适合稠密图。

模板
java 复制代码
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int n, m;
    static int[] father; // 记录并查集中每个节点的父节点
    static Node[] Q; // 存储边的信息,包括起点、终点和权值

    static class Node {
        int x; // 边的起点
        int y; // 边的终点
        int k; // 边的权值

        public Node(int x, int y, int k) {
            this.x = x;
            this.y = y;
            this.k = k;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt(); // 顶点数量
        m = scanner.nextInt(); // 边的数量

        father = new int[n + 1]; // 初始化并查集
        Q = new Node[m]; // 初始化边的数组

        int cont = 0, sum = 0, st = 0; // cont用于统计边的数量,sum为最小生成树的权值,st为边的数量

        // 读取边的信息,并统计所有边的权值总和
        for (int i = 0; i < m; i++) {
            int x = scanner.nextInt(); // 边的起点
            int y = scanner.nextInt(); // 边的终点
            int k = scanner.nextInt(); // 边的权值
            Q[i] = new Node(x, y, k); // 将边的信息存储到数组中
            cont += k; // 统计边的权值总和
        }

        Arrays.sort(Q, (a, b) -> a.k - b.k); // 根据边的权值进行排序

        for (int i = 1; i <= n; i++)
            father[i] = i; // 初始化并查集,每个顶点的父节点都是自己

        // 遍历所有边,并使用并查集找出最小生成树
        for (int i = 0; i < m; i++) {
            int tx = find(Q[i].x); // 找到起点的根节点
            int ty = find(Q[i].y); // 找到终点的根节点
            if (tx != ty) { // 如果起点和终点的根节点不相同,说明加入这条边不会形成环
                sum += Q[i].k; // 将这条边的权值加入到最小生成树的权值中
                st++; // 边的数量加一
                father[tx] = ty; // 将起点的根节点指向终点的根节点,表示它们在同一个连通分量中
                if (st == n - 1) // 如果边的数量等于顶点数量减一,说明最小生成树已经构建完成
                    break;
            }
        }

        System.out.println(sum); // 输出最小生成树的权值
    }

    // 并查集的查找函数,用于查找节点的根节点
    static int find(int x) {
        if (father[x] == x) // 如果节点的父节点就是它自己,说明它是根节点
            return x;
        return father[x] = find(father[x]); // 否则递归查找父节点,同时进行路径压缩
    }

}

编程40 蓝桥王国

题目描述

小明是蓝桥王国的王子,今天是他登基之日。

在即将成为国王之前,老国王给他出了道题,他想要考验小明是否有能力管理国家。

题目的内容如下:

蓝桥王国一共有 NN 个建筑和 MM 条单向道路,每条道路都连接着两个建筑,每个建筑都有自己编号,分别为 1∼N1\sim N。(其中皇宫的编号为 11)

国王想让小明回答从皇宫到每个建筑的最短路径是多少,但紧张的小明此时已经无法思考,请你编写程序帮助小明回答国王的考核。

输入描述

输入第一行包含三个正整数 N,MN,M。

第 22 到 M+1M +1 行每行包含三个正整数 u,v,wu,v,w,表示 11 之间存在一条距离为 ww 的路。
1≤N≤3×105,1≤m≤106,1≤ui,vi≤N,0≤wi≤1091\leq N\leq3\times10^5,1\leq m\leq10^6,1\leq u_i,v_i\leq N,0\leq w_i\leq 10^9。

输出描述

输出仅一行,共 NN 个数,分别表示从皇宫到编号为 1∼N1\sim N 建筑的最短距离,两两之间用空格隔开。(如果无法到达则输出 −1-1)

输入输出样例

示例1

输入

sh 复制代码
3 3 
1 2 1
1 3 5
2 3 2

输出

sh 复制代码
0 1 3

运行限制

image.png

题解

这题的话求单源最短路径。故我们可以使用 dijkstra 算法来解决问题。

java 复制代码
import java.io.*;
import java.util.*;

public class Main {

	// 边
	private static class Edge {
		int from, to;
		long w;

		Edge(int a, int b, long w) {
			this.from = a;
			this.to = b;
			this.w = w;
		}
	}

	// 用于优先队列,优先选取从权值和最小的结点作为中转节点
	private static class SNode implements Comparable<SNode> {
		int id; // 结点编号
		long n_dis; // 存储从起点到该结点的最短权值和

		SNode(int id, long n_dis) {
			this.id = id;
			this.n_dis = n_dis;
		}

		@Override
		public int compareTo(SNode o) {
			return Long.compare(this.n_dis, o.n_dis);
		}

	}

	static int N = 300005;
	static long INF = 0x3f3f3f3f3f3f3f3fL;
	// 存储从 1 ~ n 的邻接边
	static ArrayList<Edge>[] e = new ArrayList[N];
	static int n, m;
	static int[] pre = new int[N]; // 存储编号的前驱节点
	static long[] dis = new long[N]; // 存储 1 到 每个节点的最短路径值
	static boolean[] vistied = new boolean[N]; // 标记是否访问过

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

	public static void main(String[] args) throws IOException {
		StringTokenizer st = new StringTokenizer(br.readLine());
		n = Integer.parseInt(st.nextToken());
		m = Integer.parseInt(st.nextToken());
		for (int i = 1; i <= n; i++)
			e[i] = new ArrayList<>();
		for (int i = 1; i <= m; i++) {
			st = new StringTokenizer(br.readLine());
			int u = Integer.parseInt(st.nextToken());
			int v = Integer.parseInt(st.nextToken());
			long w = Long.parseLong(st.nextToken());
			e[u].add(new Edge(u, v, w));
			// e[v].add(new Edge(v, u, w)); //本题是单向道路
		}

//		Scanner sc = new Scanner(System.in);
//		n = sc.nextInt(); // 节点数
//		m = sc.nextInt(); // 边数
//
//		// 初始化邻接列表
//		for (int i = 1; i <= n; i++) {
//			e[i] = new ArrayList<Edge>();
//		}
//
//		for (int i = 1; i <= m; i++) {
//			int u = sc.nextInt();
//			int v = sc.nextInt();
//			int w = sc.nextInt();
//			// 存储当前节点 u 的边(邻接边)
//			e[u].add(new Edge(u, v, w));
////			e[v].add(new Edge(u, v, w)); 这道题是单向道路
//		}

		dijkstra(1);
		for (int i = 1; i <= n; i++) {
			if (dis[i] >= INF) {
				System.out.print("-1 ");
			} else {
				System.out.print(dis[i] + " ");
			}
		}

//		printPath(1, n);
	}

	private static void printPath(int s, int n) {
		// 到达起点,直接输出
		if (n == s) {
			System.out.print(s + " ");
			return;
		}
		// 递归去找前驱结点,知道找到起点,开始出栈进行打印输出
		printPath(s, pre[n]);
		System.out.print(n + " ");
	}

	/**
	 * 迪杰斯特拉
	 * 
	 * @param start 起点编号
	 */
	private static void dijkstra(int start) {
		// 初始化 1 到 每个点的权值无穷大
		Arrays.fill(dis, INF);
		dis[start] = 0; // 起点到自己本身是0
		// 存储待处理的节点
		// 注意,该队列是按照我们比较器的顺序来取出元素的。
		PriorityQueue<SNode> queue = new PriorityQueue<>();
		// 将起点加入待处理
		queue.add(new SNode(start, dis[start]));

		while (!queue.isEmpty()) {
			SNode node = queue.poll();
			// 查看该节点是否处理过
			if (vistied[node.id])
				continue;
			vistied[node.id] = true;
			// 访问其邻接节点
			for (Edge edge : e[node.id]) {
				// 访问未被处理过的邻接节点
				if (vistied[edge.to]) {
					continue;
				}
				// 计算从起点经过 node 到达 edge 的权值,看看是否比原来的更好
				dis[edge.to] = Math.min(dis[edge.to], node.n_dis + edge.w);
				// 添加到待处理队列
				queue.add(new SNode(edge.to, dis[edge.to]));
				pre[edge.to] = node.id; // 记录前驱节点,用于溯源
			}
		}
	}
}

编程41 随机数据下的最短路问题

题目描述
给定 NN 个点和 MM 条单向道路,每条道路都连接着两个点,每个点都有自己编号,分别为 1∼N1\sim N。

问你从 SS 点出发,到达每个点的最短路径为多少。

输入描述

输入第一行包含三个正整数 N,M,SN,M,S。

第 22 到 M+1M +1 行每行包含三个正整数 u,v,wu,v,w,表示 u vu\ v 之间存在一条距离为 ww 的路。

1≤N≤5×103,1≤M≤5×104,1≤ui,vi≤N,0≤wi≤1091\leq N\leq5\times10^3,1\leq M\leq5\times 10^4,1\leq u_i,v_i\leq N, 0\leq w_i\leq10^9。

本题数据随机生成。

输出描述

输出仅一行,共 NN 个数,分别表示从编号 SS 到编号为 1∼N1\sim N 点的最短距离,两两之间用空格隔开。(如果无法到达则输出 −1-1)

输入输出样例

示例1

输入

sh 复制代码
3 3 1
1 2 1
1 3 5
2 3 2

输出

sh 复制代码
0 1 3

运行限制
image.png

题解

这题可以使用 dijkstra 算法解决,但既然学习了 spfa 算法,它也可以求解最短单源路径问题,这里就来练练手吧。

需要注意的是:

在 SPFA 算法中,当一个节点从队列中取出并进行处理后,可能会更新与其相邻节点的距离。如果这些相邻节点之前已经被访问过,那么可能会再次被加入到队列中等待处理。重新标记为未访问的目的是为了允许相邻节点再次被处理,因为它们可能会在后续的松弛操作中更新其它节点的距离。

具体来说,考虑以下情况:

  1. 初始时,将起始节点加入到队列中并标记为已访问。
  2. 当从队列中取出一个节点进行处理时,可能会更新与该节点相邻节点的距离。
  3. 如果某个相邻节点之前已经被访问过(即在队列中),并且更新后的距离比之前更小,那么这个相邻节点就应该再次被加入到队列中等待处理。
  4. 因此,为了保证相邻节点能够再次被加入到队列中,需要将其重新标记为未访问状态,这样在下一轮循环时它才能再次被处理。
  5. 这样做的目的是确保算法可以继续进行松弛操作,直到没有节点需要再次更新为止。
java 复制代码
import java.io.*;
import java.util.*;

// 随机数据下的最短路问题
public class Main {

	private static class Edge {
		int to;
		long w;

		Edge(int to, long w) {
			this.to = to;
			this.w = w;
		}
	}

	static final long INF = 0x3f3f3f3f3f3f3L;
	static final int N = 5010;
	static long[] dist = new long[N]; // 存储起点到每个点的最短路径
	static List<Edge>[] e = new ArrayList[N]; // 存储每个节点的邻接边
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static boolean[] vistied = new boolean[N];

	public static void main(String[] args) throws IOException {
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken()); // n个结点
		int m = Integer.parseInt(st.nextToken()); // m条单向道路
		int s = Integer.parseInt(st.nextToken()); // 起点编号

		for (int i = 1; i <= n; i++) {
			e[i] = new ArrayList<>();
		}

		for (int i = 1; i <= m; i++) {
			st = new StringTokenizer(br.readLine());
			int u = Integer.parseInt(st.nextToken()); // 起点
			int v = Integer.parseInt(st.nextToken()); // 终点
			int w = Integer.parseInt(st.nextToken()); // 权值
			e[u].add(new Edge(v, w));
		}

		spfa(s);

		for (int i = 1; i <= n; i++) {
			if (dist[i] >= INF) {
				System.out.print("-1 ");
			} else {
				System.out.print(dist[i] + " ");
			}
		}
	}

	/**
	 * spfa 算法
	 * 
	 * @param s 起点编号
	 */
	private static void spfa(int s) {
		// 初始化
		Arrays.fill(dist, INF);
		dist[s] = 0;

		// 注意,这里和迪杰斯特拉的优先队列不同
		// 我们只要先进先出即可,存放待处理的结点编号
		Queue<Integer> queue = new LinkedList<>();
		queue.add(s);
		vistied[s] = true; // 标记为需要处理

		while (!queue.isEmpty()) {
			// 拿到即将要处理的编号
			int u = queue.poll();
			// 重新标记为未处理,防止相邻节点某些状态更新了这个节点没有来的及更新
			vistied[u] = false;
			// 之前该节点已经访问过了,值还是无穷大,则说明 s 无法到达 u
			if (dist[u] == INF)
				continue;
			// 访问邻接边
			for (Edge e : e[u]) {
				int to = e.to;
				long w = e.w;
				// 看看 s 能否根据 u 到达 to 时距离比原先更短
				if (dist[to] > w + dist[u]) {
					dist[to] = w + dist[u]; // 更新最短路径
					// 如果该节点已经在队列中,则无需重复添加了
					if (vistied[to]) {
						continue;
					}
					queue.add(to);
					vistied[to] = true;
				}
			}
		}
	}
}

编程42 出差

问题描述

AA 国有 NN 个城市,编号为 1⋯N1\cdots N。小明是编号为 11 的城市中一家公司的员工,今天突然接到了上级通知需要去编号为 NN 的城市出差。

由于疫情原因,很多直达的交通方式暂时关闭,小明无法乘坐飞机直接从 城市 11 到达城市 NN,需要通过其他城市进行陆路交通中转。小明通过交通信息网,查询到了 MM 条城市之间仍然还开通的路线信息以及每一条路线需要花费的时间。

同样由于疫情原因,小明到达一个城市后需要隔离观察一段时间才能离开该城市前往其他城市。通过网络,小明也查询到了各个城市的隔离信息。(由于小明之前在城市 11,因此可以直接离开城市 11,不需要隔离)

由于上级要求,小明希望能够尽快赶到城市 NN, 因此他求助于你,希望你 能帮他规划一条路线,能够在最短时间内到达城市 NN。

输入格式

第 11 行:两个正整数 N,MN,M,NN 表示 AA 国的城市数量,MM 表示末关闭的路线数量
第 22 行:NN 个正整数,第 ii 个整数 CiC_i,表示到达编号为 ii 的城市后需要隔离的时间
第 3⋯M+23\cdots M +2 行:每行 33 个正整数,u,v,cu,v,c,表示有一条城市 uu 到城市vv 的双向路线仍然开通着,通过该路线的时间为 cc。

输出格式

第 11 行:11 个正整数,表示小明从城市 11 出发到达城市 NN 的最短时间(到达城市 NN,不需要计算城市 NN 的隔离时间)

输入输出样例

示例1

输入

sh 复制代码
4 4
5 7 3 4
1 2 4
1 3 5
2 4 3
3 4 5

输出

sh 复制代码
13

样例说明

image.png

评测用例规模与约定
对于 100%100\% 的数据,1≤N≤1000,1≤M≤10000,1≤Ci≤200,1≤u,v≤N,1≤c≤10001 \leq N \leq 1000,1 \leq M \leq 10000,1 \leq C_i \leq 200,1 \leq u,v \leq N,1\leq c\leq1000

运行限制

image.png

题解

这里使用 dijkstra 来做,使用邻接矩阵存储图,不使用优先队列,使用传统的循环找到未被处理、路径权值和最小的点来作为中转结点,找出最短路径。

java 复制代码
import java.util.*;

// 出差
public class Main {

	static final int INF = 0x3f3f3f3f;
	static final int N = 1010;

	static int[][] graph = new int[N][N];
	static int[] dist = new int[N]; // 到达每个国家的最短单源路径
	static boolean[] vis = new boolean[N];
	static int[] times = new int[N]; // 存储每个国家的隔离时间

	static int n, m;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();

		for (int i = 1; i <= n; i++) {
			times[i] = sc.nextInt();
			// 顺便初始化,默认所有节点无法到达
			Arrays.fill(graph[i], INF);
		}
		times[n] = 0; // 终点的隔离时间无需考虑,故设置为0

		for (int i = 1; i <= m; i++) {
			int u = sc.nextInt();
			int v = sc.nextInt();
			int c = sc.nextInt();
			// 加上相应的隔离时间
			graph[u][v] = c + times[v];
			graph[v][u] = c + times[u];
		}

		dijkstra();
		System.out.print(dist[n]);
	}

	private static void dijkstra() {
		Arrays.fill(dist, INF);
		dist[1] = 0;

		for (int i = 0; i < n; i++) {
			int cur = -1;
			// 找到一个未被访问过的,且权值访问路径最小的节点
			for (int j = 1; j <= n; j++) {
				if (!vis[j] && (cur == -1 || dist[cur] > dist[j])) {
					cur = j;
				}
			}
			// 所有节点都被处理过,结束
			if (cur == -1)
				break;
			// 计算每一个节点通过中转 cur 到达 j 的路径是否比原来的更短
			for (int j = 1; j <= n; j++) {
				dist[j] = Math.min(dist[cur] + graph[cur][j], dist[j]);
			}
			vis[cur] = true;
		}
	}
}

编程43 聪明的猴子

题目描述

在一个热带兩林中生存着一群猴子,它们以树上的果子为生。昨天下了一场大雨,现在雨过天晴,但整个雨林的地表还是被大水淹没着,部分植物的树冠露在水面上。猴子不会游泳,但跳跃能力比较强,它们仍然可以在露出水面的不同树冠上来回穿梭,以找到喜欢吃的果实。

现在,在这个地区露出水面的有 NN 棵树,假设每棵树本身的直径都很小,可以忽略不计。我们在这块区域上建立直角坐标系,则每一棵树的位置由其所对应的坐标表示(任意两棵树的坐标都不相同)。

在这个地区住着的猴子有 MM 个,下雨时,它们都躲到了茂密高大的树冠中,没有被大水冲走。由于各个猴子的年龄不同、身体素质不同,它们跳跃的能力不同。有的猴子跳跃的距离比较远(当然也可以跳到较近的树上),而有些猴子跳跃的距离就比较近。这些猴子非常聪明,它们通过目测就可以准确地判断出自己能否跳到对面的树上。

现已知猴子的数量及每一个猴子的最大跳跃距离,还知道露出水面的每一棵树的坐标,你的任务是统计有多少个猴子可以在这个地区露出水面的所有树冠上觅食。

输入描述

第 11 行为一个整数,表示猴子的个数 M(2≤M≤500)M(2 \leq M \leq 500);

第 22 行为 MM 个整数,依次表示猴子的最大跳跃距离(每个整数值在 1∼10001 \sim 1000之间);

第 33 行为一个整数表示树的总棵数 N(2≤N≤1000)N(2\leq N \leq 1000);

第 44 行至第 N+3N+3 行为 NN 棵树的坐标(横纵坐标均为整数,范围为: −1000∼1000-1000 \sim 1000)。

(同一行的整数间用空格分开)

输出描述

输出一个整数,表示可以在这个地区的所有树冠上觅食的猴子数。

输入输出样例

示例1

输入

sh 复制代码
4
1 2 3 4
6
0 0
1 0
1 2
-1 -1
-2 0
2 2

输出

sh 复制代码
3

运行限制
image.png

题解

题目求能在所有树上觅食,那如果猴子的跳跃距离大于最小生成树的最大边,那它就可以在所有树上跳跃,故我们可以使用 kruskal 来求出最小生成树,找到距离最大的边,最后就可以求出多少个猴子可以在所有树上觅食了。

java 复制代码
import java.util.*;

// 聪明的猴子
public class Main {

	// 边,按权值最小的排序
	private static class Edge implements Comparable<Edge> {
		int x;
		int y;
		double w;

		Edge(int x, int y, double w) {
			this.x = x;
			this.y = y;
			this.w = w;
		}

		@Override
		public int compareTo(Edge o) {
			return Double.compare(this.w, o.w);
		}

	}

	static final int N = 10010;
	static final int INF = 0x3f3f3f3f;
	static int m; // 猴子个数
	static int n; // 树的颗数
	static int[] father = new int[N]; // 并查集
	static int[] monkeys = new int[N]; // 存储每个猴子的最大跳跃距离
	static int[] tree_x = new int[N]; // 树的横坐标
	static int[] tree_y = new int[N]; // 树的纵坐标
	static double max; // 最小生成树中最大的权值

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		m = sc.nextInt(); // 猴子个数
		for (int i = 0; i < m; i++) {
			monkeys[i] = sc.nextInt();
		}
		n = sc.nextInt(); // 树的颗数
		for (int i = 0; i < n; i++) {
			tree_x[i] = sc.nextInt();
			tree_y[i] = sc.nextInt();
		}
		// 存储边
		List<Edge> edges = new ArrayList<>();
		// 找到所有树的边
		for (int i = 0; i < n - 1; i++) {
			for (int j = i + 1; j < n; j++) {
				// 计算两颗树的距离
				double w = Math.sqrt((tree_x[i] - tree_x[j]) * (tree_x[i] - tree_x[j])
						+ (tree_y[i] - tree_y[j]) * (tree_y[i] - tree_y[j]));
				edges.add(new Edge(i, j, w));
			}
		}

		kruskal(edges);

		// 到这里我们找到了最小生成树中权值最大的边
		int ans = 0;
		for (int i = 0; i < m; i++) {
			// 找出能跳过最大边的猴子
			if (monkeys[i] >= max) {
				ans++;
			}
		}
		System.out.print(ans);
	}

	/**
	 * 克鲁斯卡尔算法(贪心策略)
	 * 
	 * @param edges
	 */
	private static void kruskal(List<Edge> edges) {
		// 按权值最小的边排序
		Collections.sort(edges);

		// 初始化并查集
		for (int i = 0; i < n; i++) {
			father[i] = i;
		}
		int num = 0; // 最小生成树的边(n-1)
		// 找出最小生成树中的最短路径中的最长边
		for (Edge e : edges) {
			int a = find(e.x);
			int b = find(e.y);
			// 如果起点与终点的根结点不同,说明不会构成环
			if (a != b) {
				father[a] = b; // 加入最小生成树
//				merge(e.x, e.y);
				// 找出权值最大的边
				max = Math.max(max, e.w);
				num++;
				// 最小生成树的边 = 顶点数 -1,达到了,说明最小生成树构建完成
				if (num == n - 1) {
					break;
				}
			}
		}

	}

	/**
	 * 合并两个结点
	 * 
	 * @param x
	 * @param y
	 */
	private static void merge(int x, int y) {
		int a = find(x);
		int b = find(y);
		// 两个根节点不相同,进行合并
		if (a != b) {
			father[b] = a;
		}
	}

	/**
	 * 查找 x 的根节点
	 * 
	 * @param x
	 * @return
	 */
	private static int find(int x) {
		if (father[x] == x) {
			return x;
		}
		father[x] = find(father[x]);
		return father[x];
	}

}

编程44 通电

题目描述

2015 年,全中国实现了户户通电。作为一名电力建设者,小明正在帮助一带一路上的国家通电。

这一次,小明要帮助 nn 个村庄通电,其中 1 号村庄正好可以建立一个发电站,所发的电足够所有村庄使用。

现在,这 nn 个村庄之间都没有电线相连,小明主要要做的是架设电线连接这些村庄,使得所有村庄都直接或间接的与发电站相通。

小明测量了所有村庄的位置(坐标)和高度,如果要连接两个村庄,小明需要花费两个村庄之间的坐标距离加上高度差的平方,形式化描述为坐标为 (x1,y1)(x_1,y_1) 高度为 h1h_1 的村庄与坐标为 (x2,y2)(x_2,y_2) 高度为 h2h_2 的村庄之间连接的费用为

(x1−x2)2+(y1−y2)2+(h1−h2)2\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}+(h_1-h_2)^2

高度的计算方式与横纵坐标的计算方式不同。

由于经费有限,请帮助小明计算他至少要花费多少费用才能使这几个村庄都通电。

输入描述

输入的第一行包含一个整数 nn,表示村庄的数量。

接下来 nn 行,每个三个整数 x,y,hx,y,h,分别表示一个村庄的横、纵坐标和高度,其中第一个村庄可以建立发电站。

其中,1≤n≤1000,0≤x,y,h≤100001\leq n \leq1000,0\leq x,y,h\leq 10000。

输出描述

输出一行,包含一个实数,四舍五入保留 2 位小数,表示答案。

输入输出样例

示例1

输入

sh 复制代码
4
1 1 3
9 9 7
8 8 6
4 5 4

输出

sh 复制代码
17.41

运行限制

image.png

题解

这题的话,我们根据其提供的公式,先找出每个节点之间的边(权值为费用),那之后我们就可以求出 MST,那么 MST 的权值之和就是我们要的答案。这里由于题目数据不多,我就采用 kruskal 求出 MST。

java 复制代码
import java.util.*;

// 通电
public class Main {

	private static class Edge implements Comparable<Edge> {
		int x;
		int y;
		double w;

		Edge(int x, int y, double w) {
			this.x = x;
			this.y = y;
			this.w = w;
		}

		@Override
		public int compareTo(Edge o) {
			// TODO Auto-generated method stub
			return Double.compare(this.w, o.w);
		}
	}

	static int n;
	static int[] x;
	static int[] y;
	static int[] h;
	static int[] father;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		x = new int[n];
		y = new int[n];
		h = new int[n];
		father = new int[n];
		for (int i = 0; i < n; i++) {
			x[i] = sc.nextInt();
			y[i] = sc.nextInt();
			h[i] = sc.nextInt();
		}

		List<Edge> list = new ArrayList<>();

		// 找出每一条边
		for (int i = 0; i < n - 1; i++) {
			for (int j = i + 1; j < n; j++) {
				// i 到 j 的费用
				double w = Math.sqrt(Math.pow(x[i] - x[j], 2) + Math.pow(y[i] - y[j], 2)) + Math.pow(h[i] - h[j], 2);
				list.add(new Edge(i, j, w));
			}
		}

		kruskal(list);
	}

	/**
	 * 克鲁斯卡尔
	 * 
	 * @param list
	 */
	private static void kruskal(List<Edge> list) {
		// 按权值最小排序
		Collections.sort(list);
		// 初始化并查集
		for (int i = 0; i < n; i++) {
			father[i] = i;
		}
		double ans = 0; // 最小生成树的所有权值和
		int num = 0; // 最小生成树的边
		for (Edge e : list) {
			int a = find(e.x); // 寻找起点的根节点
			int b = find(e.y); // 寻找终点的根节点
			// 两个根不同,说明不会形成环
			if (a != b) {
				father[a] = b;
				ans += e.w;
				num++;
				// 如果边达到节点数-1,说明最小生成树构成
				if (num == n - 1) {
					break;
				}
			}
		}
		System.out.printf("%.2f", ans);
	}

	/**
	 * 找到根节点
	 * 
	 * @param x
	 * @return
	 */
	private static int find(int x) {
		if (father[x] == x) {
			return x;
		}
		father[x] = find(father[x]);
		return father[x];
	}
}

也使用 Prim 解下这题吧。

java 复制代码
import java.util.*;

// 通电
public class Main {

	static final int INF = 0x3f3f3f3f;
	static int n; // 顶点数量
	static int[] x;
	static int[] y;
	static int[] h;
	static double[][] graph; // 存储两个村庄之间的权值

	static int[] close_num; // 存储每个节点最近的编号
	static double[] low_w; // 存储生成树到达某个节点的最小权值

	static List<Double> demo = new ArrayList<>(); // 存储每个点最小边的权值

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		x = new int[n];
		y = new int[n];
		h = new int[n];
		close_num = new int[n];
		low_w = new double[n];
		graph = new double[n][n];
		for (int i = 0; i < n; i++) {
			x[i] = sc.nextInt();
			y[i] = sc.nextInt();
			h[i] = sc.nextInt();
		}

		// 计算村庄的边
		for (int i = 0; i < n - 1; i++) {
			for (int j = i + 1; j < n; j++) {
				int l = x[i] - x[j];
				int r = y[i] - y[j];
				int he = h[i] - h[j];
				double w = Math.sqrt(l * l + r * r) + he * he;
				graph[i][j] = graph[j][i] = w;
			}
		}

		prim();

	}

	/**
	 * 普里姆算法
	 */
	private static void prim() {
		for (int i = 0; i < n; i++) {
			close_num[i] = 0; // i 的最近结点默认为 0
			low_w[i] = INF; // 默认 MST 到达 i的距离为无穷大
		}

		// 标记为已经加入最小生成树
		close_num[0] = -1;

		int num = 0; // 边数
		double ans = 0; // MST 权值和
		int e = 0; // 最新加入 MST 的点,查找其最小的边

		while (num < n - 1) {
			double min_w = INF; // MST 到达该节点的最小权值
			int min_num = -1; // 最小的结点编号
			for (int i = 0; i < n; i++) {
				// 已加入 MST 的节点不处理
				if (close_num[i] == -1) {
					continue;
				}
				// 最小生成树通过 node 到达 i
				double temp = graph[e][i];
				// 如果权值比之前的小,则更新
				if (temp < low_w[i]) {
					low_w[i] = temp; // 更新权值
					// i 最近的邻接点标记为 node
					close_num[i] = e;
				}
				// 找到最小权值
				if (low_w[i] < min_w) {
					min_num = i;
					min_w = low_w[i];
				}
			}
			demo.add(min_w);
			// 累加权值和
			ans += min_w;
			// 下次需要查找最近结点的编号
			e = min_num;
			// 加入最小生成树
			close_num[e] = -1;
			num++;

		}
		System.out.printf("%.2f", ans);
	}
}

编程45 机房

问题描述

这天,小明在机房学习。

他发现机房里一共有 nn 台电脑,编号为 11 到 nn,电脑和电脑之间有网线连接,一共有 n−1n-1 根网线将 nn 台电脑连接起来使得任意两台电脑都直接或者间接地相连。

小明发现每台电脑转发、发送或者接受信息需要的时间取决于这台电脑和 多少台电脑直接相连,而信息在网线中的传播时间可以忽略。比如如果某台电脑 用网线直接连接了另外 dd 台电脑,那么任何经过这台电脑的信息都会延迟 dd 单位时间(发送方和接收方也会产生这样的延迟,当然如果发送方和接收方都是同一台电脑就只会产生一次延迟)。

小明一共产生了 mm 个疑问:如果电脑 uiu_i 向电脑 viv_i 发送信息,那么信息从 uiu_i 传到 viv_i 的最短时间是多少?

输入格式

输入共 n+mn+m 行,第一行为两个正整数 n,mn,m。

后面 n−1n-1 行,每行两个正整数 x,yx,y 表示编号为 xx 和 yy 的两台电脑用网线直接相连。

后面 mm 行,每行两个正整数 ui,viu_i,v_i 表示小明的第 ii 个疑问。

输入输出样例

示例1

输入

sh 复制代码
4 3
1 2
1 3
2 4
2 3
3 4
3 3

输出

sh 复制代码
5
6
1

样例说明

这四台电脑各自的延迟分别为 2,2,1,12,2,1,1。

对于第一个询问,从22 到 33 需要经过 2,1,32,1,3,所以时间和为 2+2+1=52+2+1=5。

对于第二个询问,从 33 到 44 需要经过 3,1,2,43,1,2,4,所以时间和为 1+2+2+1=61+2+2+1=6。

对于第三个询问,从 33 到 33 只会产生一次延迟,所以时间为 11。

评测用例规模与约定

对于 3030% 的数据,保证 n,m≤1000n,m \leq 1000;

对于 100100% 的数据,保证 n,m≤100000n,m\leq100000。

运行限制

image.png

题解

java 复制代码

编程46 环境治理

输入输出样例

示例1

输入

sh 复制代码
3 10
0 2 4
2 0 1
4 1 0
0 2 2
2 0 0
2 0 0

输出

sh 复制代码
2

评测用例规模与约定

对于 3030% 的数据,保证 n,m≤1000n,m \leq 1000;

对于 100100% 的数据,保证 n,m≤100000n,m\leq100000。

运行限制

image.png

题解

java 复制代码

12. 简单数论

编程47 刷题统计

问题描述

小明决定从下周一开始努力刷题准备蓝桥杯竞赛。他计划周一至周五每天 做 aa 道题目,周六和周日每天做 bb 道题目。请你帮小明计算,按照计划他将在 第几天实现做题数大于等于 nn 题?

输入格式

输入一行包含三个整数 a,ba,b 和 nn.

输出格式

输出一个整数代表天数。

输入输出样例

示例1

输入

sh 复制代码
10 20 99

输出

sh 复制代码
8

评测用例规模与约定

对于 50%50\%的评测用例,1≤a,b,n≤1061\leq a,b,n \leq 10^6.
对于 100%100\% 的评测用例,1≤a,b,n≤10181\leq a,b,n \leq 10^{18}.

运行限制

image.png

题解

这题就是简单的取余计算,算出每周做满题的话有多少,然后 n/一周做的题数就是做了多少周,再乘以 7 天就是做了多少天,接着看看有无剩余未做的题。根据是否在工作日可以做完,还是得到周末做完即可。

java 复制代码
import java.util.*;

// 刷题统计
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long a = sc.nextLong();
		long b = sc.nextLong();
		long n = sc.nextLong();
		long week = a * 5 + b * 2; // 每周做多少题
		long days = n / week * 7; // 做了多少周 * 7天
		n = n % week; // 余下的题目
		if (n <= a * 5) {
			// 剩余的题量在周一至周五可以完成
			// 如果除不尽,还得多做一天
			days += n / a + (n % a == 0 ? 0 : 1);
		} else {
			// 加上周一周五的天数
			days += 5;
			// 减去五天做了的题目数
			n -= 5 * a;
			// 周末做的天数
			days +=  n / b + (n % b == 0 ? 0 : 1);
		}
		System.out.print(days);
	}
}

编程48 快速幂

题目描述

输入 bb,pp,kk 的值,求 bpmod  kb^p \mod k 的值。其中 2≤b,p,k≤1092\leq b,p,k\leq 10^9。

输入描述

三个整数 b,p,kb,p,k。

输出描述

输出 bpmod  k=sb^p \mod k=s,ss 为运算结果。

输入输出样例

示例1

输入

sh 复制代码
2 10 9

输出

sh 复制代码
7

运行限制

image.png

题解

这题的话,直接计算的话会溢出,我们可以使用快速幂来解决这题。

思路:

  1. 定义一个结果变量 ans,初值为1;先对底数 a 取余,防止溢出;
  2. 之后每次循环先判断指数 n 是否是奇数(二进制最低位为 1),是的话,把当前 a 乘 ans 并取余,赋值给 ans;
  3. 无论底数是否是奇数,都对指数n 右移1位,并将当前的 a 做一次平方并取模,更新自己;
  4. 直到指数右移到为0,结束本次循环,对 a 的 n 次幂取余也计算完成。
java 复制代码
// 快速幂
public class Main {
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long b = sc.nextLong();
		long p = sc.nextLong(); // 幂
		long k = sc.nextLong(); // 取模值
		System.out.println(fastPow(b, p, k));
	}

	/**
	 * 快速幂
	 * 
	 * @param a   底数
	 * @param n   多少次方
	 * @param mod 模
	 * @return
	 */
	private static long fastPow(long a, long n, long mod) {
		long ans = 1;
		a %= mod; // 重要,防止下面的ans*a越界
		// 第一轮,因为 p是10,我们先对求出 b 的平方,那么 接下来我们将 p/2=5,s是1
		// 第二轮,因为 p是5,是奇数,则先乘以一次 b,得出 s=b^2,接着将b 由原来b的平方变成 b^4,p/2=2
		// 第三轮,因为 p是2,则上一次的b的二次方等于 b^8,p/2=1
		// 第四轮,因为 p是1,是奇数,则需要乘以 s=b^2*b^8=b^10,p/2=0
		// 第五轮,p是0,结束
		while (n > 0) {
			// 判断指数是否是奇数,是的话,先乘一次
			if ((n & 1) == 1) {
				ans = ans * a % mod;
			}
			// 计算 a的平方,并防止溢出
			a = a * a % mod;
			// 除以2
			// n /= 2; 相当于 n=n/2
			n >>= 1;
		}
		return ans;
	}
}

编程49 核桃的数量

题目描述

小张是软件项目经理,他带领 33 个开发组。工期紧,今天都在加班呢。为鼓舞士气,小张打算给每个组发一袋核桃(据传言能补脑)。他的要求是:

  1. 各组的核桃数量必须相同
  2. 各组内必须能平分核桃(当然是不能打碎的)
  3. 尽量提供满足 1,2 条件的最小数量(节约闹革命嘛)

输入描述
输入一行 a,b,ca,b,c, 都是正整数,表示每个组正在加班的人数,用空格分开(a,b,c<30)(a,b,c< 30)。

输出描述

输出一个正整数,表示每袋核桃的数量。

输入输出样例

示例1

输入

sh 复制代码
2 4 5

输出

sh 复制代码
20

运行限制

image.png

题解

这题题目说要能平分(能被整除)、每一组数量相同且尽量最小数量,那不就是求这三组人数的最小公倍数嘛,这个数字刚好就满足能被这三组的人整除,值也尽量最小。直接套模板。

java 复制代码
import java.util.Scanner;

// 核桃的数量
public class Main {

	/**
	 * 求出最大公约数
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
	private static int gcd(int a, int b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	/**
	 * 最小公倍数
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
	private static int lcm(int a, int b) {
		return a / gcd(a, b) * b; // 先做除法再做乘法,防止乘法溢出
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int c = sc.nextInt();
		// 求出这三个数的最小公倍数
		int res = lcm(lcm(a, b), c);
		System.out.print(res);
	}
}

编程50 质数

题目描述

给定一个正整数 NN,请你输出 NN 以内(不包含 NN)的质数以及质数的个数。

输入描述

输入一行,包含一个正整数 NN。1≤N≤1031\leq N\leq10^3

输出描述

共两行。

第 11 行包含若干个素数,每两个素数之间用一个空格隔开,素数从小到大输出。

第 22 行包含一个整数,表示 NN 以内质数的个数。

输入输出样例

示例1

输入

sh 复制代码
10

输出

sh 复制代码
2 3 5 7
4

运行限制

image.png

题解

素数是除了 1 与自己本身,不能被其它数整除的数。(特别地,1不是素数)

有三个方法可以解决这个问题,一般会暴力筛一个个判断或者埃式筛就可以了。

java 复制代码
import java.util.Arrays;
import java.util.Scanner;

// 质数
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
//		method1(n);
		method2(n);
//		method3(n);
	}

	/**
	 * 欧式线性筛法
	 * 
	 * @param n
	 */
	private static void method3(int n) {
		int[] primes = new int[n + 1];
		boolean[] noPrime = new boolean[n + 1];
		int cnt = 0;

		for (int i = 2; i < n; i++) {
			// 该数未被标记为不是素数
			if (!noPrime[i]) {
				primes[cnt++] = i;
			}
			// 找出之前已经找出的素数,
			for (int j = 0; j < cnt && i * primes[j] < n; j++) {
				noPrime[i * primes[j]] = true;
				if (i % primes[j] == 0) {
					break;
				}
			}
		}
		for (int i = 0; i < cnt; i++) {
			System.out.print(primes[i] + " ");
		}
		System.out.println("\n" + cnt);
	}

	/**
	 * 埃式筛
	 * 
	 * @param n
	 */
	private static void method2(int n) {
		int[] prime = new int[n + 1];
		boolean[] noPrime = new boolean[n + 1];
		int cnt = 0; // 记录素数个数,以及下标

		Arrays.fill(noPrime, false);
		noPrime[0] = true; // 标记为不是素数
		noPrime[1] = true; // 标记为不是素数
		for (int i = 2; i < n; i++) {
			// 该数未被标记为不是素数
			if (!noPrime[i]) {
				// 一开始从2、3、5逐个素数放进素数集合里
				prime[cnt] = i;
				cnt++;
				// 当前素数的乘积就不是素数了
				for (int j = i * 2; j <= n; j += i) {
					noPrime[j] = true; // 标记为不是素数
				}
			}
		}

		for (int i = 0; i < cnt; i++) {
			System.out.print(prime[i] + " ");
		}
		System.out.println("\n" + cnt);
	}

	/**
	 * 传统判断(一个一个判断)
	 * 
	 * @param n
	 */
	private static void method1(int n) {
		int count = 0;
		for (int i = 2; i < n; i++) {
			if (isPrime(i)) {
				System.out.print(i + " ");
				count++;
			}
		}
		System.out.println("\n" + count);
	}

	/**
	 * 判断是否是素数
	 * 
	 * @param num
	 * @return
	 */
	private static boolean isPrime(int num) {
		// 1 不是素数
		if (num <= 1) {
			return false;
		}
		for (int i = 2; i <= Math.sqrt(num); i++) {
			// 能被除了 1 与 num 自己整除的数,就不是素数
			if (num % i == 0) {
				return false;
			}
		}
		return true;
	}
}

13. 组合数学

编程51 糊涂人寄信

题目描述

有一个糊涂人,写了 nn 封信和 nn 个信封,到了邮寄的时候,把所有的信都装错了信封。求装错信封可能的种类数。

输入描述

有多行读入,每行输入一个正整数 nn,表示一种情况。(n≤20)(n\leq 20)

输出描述

输出相应的答案。

输入输出样例

示例1

输入

sh 复制代码
1
3
4

输出

sh 复制代码
0
2
9

运行限制

image.png

题解

java 复制代码

编程52 小蓝吃糖果

题目描述

小蓝有 nn 种糖果,每种数量已知。

小蓝不喜欢连续 22 次吃同样的糖果。问有没有可行的吃糖方案。

输入描述

第一行是整数 n(0<n<1000000)n(0 <n<1000000)。

第二行包含 nn 个数,表示 nn 种糖果的数量 mimi, 0<mi<10000000 < mi < 1000000。

输出描述

输出一行,包含一个 Yes 或 No。

输入输出样例

示例1

输入

sh 复制代码
3
4 1 1

输出

sh 复制代码
No

运行限制

image.png

题解

java 复制代码
觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句