DAY24

题目一

 啊 看着挺复杂 其实很简单

第一种方法

就是纵轴是怪兽编号 横轴是能力值

看看能不能打过

逻辑很简单 看看能不能打得过 打过的就在花钱和直接打里面取小的 打不过就只能花钱

这种方法就导致 如果怪兽的能力值很大 那么我们就需要很大的空间

所以引出下一种做法

纵轴是怪兽编号 横轴是钱数

我们对比一下这两种方法

1.当能力值大 钱小的情况  第一种方法浪费空间 第二种不浪费

2.当能力值小 钱多的情况 第二种浪费 第一种不浪费

所以 根据数况来取

dp[i][j] 表示正好花j元能不能打过怪兽 打不过-1 打得过就是你目前的能力值

状态转移

如果 dp[i-1][j]位置的值 大于等于当前怪兽的 能力值 那么dp[i][j]==dp[i-1][j]

如果 不大于等于 那看这个怪兽 假如说能力值是x 那就得找dp[i-1][j-x]的值 然后加上怪兽的能力

就是说 我看看打到上一个怪兽 最少需要多少钱 那么我再加上多少钱就是打败这个怪兽的值

方法一

public static long process(int[] d, int[] p, int ability, int index) {
		if (index == d.length) {
			return 0;
		}
		if (ability < d[index]) {
			return p[index] + process(d, p, ability + d[index], index + 1);
		} else { // 可以贿赂，也可以不贿赂
			return 
					Math.min(
							p[index] + process(d, p, ability + d[index], index + 1),
						    process(d, p, ability, index + 1)
							);
		}
	}

	public static long func1(int[] d, int[] p) {
		return process(d, p, 0, 0);
	}

这局部最优整体也最优吗 我想想 如果当前选择了直接打这个怪兽而获得它的能力 正好导致下一个很贵的怪兽必须花钱买怎么办

2 2 1 5

2 花钱 2直接打 1直接打 5花钱 7块

2买 2买 1买 5打 花五块

我开始以为的递归是 每一步局部最优2 花钱 2直接打 1直接打 5花钱 7块 就像这种

但实际的流程是 用动态规划来看 我这个点的钱数 是依赖于前面的最少花的钱数再加上此点最少花的钱数

动态规划

public static long func2(int[] d, int[] p) {
		int sum = 0;
		for (int num : d) {
			sum += num;
		}
		long[][] dp = new long[d.length + 1][sum + 1];
		for (int i = 0; i <= sum; i++) {
			dp[0][i] = 0;
		}
		for (int cur = d.length - 1; cur >= 0; cur--) {
			for (int hp = 0; hp <= sum; hp++) {
				// 如果这种情况发生，那么这个hp必然是递归过程中不会出现的状态
				// 既然动态规划是尝试过程的优化，尝试过程碰不到的状态，不必计算
				if (hp + d[cur] > sum) {
					continue;
				}
				if (hp < d[cur]) {
					dp[cur][hp] = p[cur] + dp[cur + 1][hp + d[cur]];
				} else {
					dp[cur][hp] = Math.min(p[cur] + dp[cur + 1][hp + d[cur]], dp[cur + 1][hp]);
				}
			}
		}
		return dp[0][0];
	}

这个动态规划怎么考虑 感觉从原来的 递归考虑好一点 直接改就可以了 也就是第一层递归出结果 dp[0][0] 我把这个任务交给你..... 这压根就是递归硬改的动态规划(精细化搜索)

和正常的从左往右尝试模型有什么不同呢?之前是一个数(钱 或者 容量)越来越少 现在是从零开始越来越多

也为我提供了个思路 不行直接写递归 再改动态规划 复习一下 本质上动态规划使用数组保存结果 减少计算次数

方法二

这次横轴是钱 dp[i][j]的位置表示严格花j块钱 通过了0....i的怪物获得的最大能力值 

严格花j元 那就是说多了也不行 8块钱能通过j==9都不行

然后推到最后一行 从左后一行里面找最左面不为-1的值

最后一行的意义是 解决掉所有怪物花的钱数 我们实际上遍历了所有可以解决掉所有怪物的方法

为什么是严格花多少钱也就出在这里

如果不是严格花多少多少钱 我们最后得出来的结果就不是 解决掉怪物的所有可能了 每一步递推过来就是错的

如果不是严格的 就说明这种组合是无效的 大于也不行 大于抓过的结果 我们之前肯定花很少的钱抓过了 而且我们最后需要的答案是每一种组合 花钱最少的 不严格算是什么样子 在某些情况下不严格不一定是错的 但是严格一定是对的

不可置否的乱写

假如说我dp[i][j] 位置往前找dp[i - 1][j - p[i]]  它是说打上一个怪物花了这么些钱能打过 它不为-1我们就加上了 i-1怪兽要10块钱 然后我们是不严格的 dp[j-p[i]]打到+11的位置上面了 本来应该是-1 现在不为-1 那我们这个位置就变成了直接花钱买 因为是取武力值大的 所以直接当前武力值加上 作为结果

但实际上 这个位置的结果是不可以加上武力值的 就是说 我们不能严格花这个钱解决这个怪兽

如果这个位置是底层的第一个不为-1 那么寄

public static int func(int [] d,int [] p) {
		int sum = 0;
		for (int i : p) {
			sum += i;
		}
		int [][] dp = new int [d.length+1][sum+1];
		for(int i = 0;i<d.length;i++) {
			for(int j = 0;j<sum+1;j++) {
				dp[i][j] = -1;
			}
		}
		dp[0][p[0]] = d[0];//第一行只有这个位置有值
		for(int i = 1;i<d.length;i++) {
			for(int j = 0;j<sum+1;j++) {
				if(j>=p[i]&&dp[i - 1][j - p[i]] != -1){//j-p[i]不越界
					dp[i][j] = dp[i - 1][j - p[i]] + d[i];
				}
				if(dp[i-1][j]>=d[i]) {
					dp[i][j] = Math.max(dp[i][j], dp[i - 1][j]);
				}//为什么要取一个能力最大的呢 这个位置的钱已经定好了 我就一定花这么多钱 为啥不取个能力大的
				//这里不用担心 哎呀 我直接买 那岂不是肯定比不买的能力值大吗 注意 这里的钱是一定的 如果这个没买 那么就有其他的钱花在别处
			}
		}
		int ans = 0;
		for (int j = 0; j <= sum; j++) {
			if (dp[d.length - 1][j] != -1) {
				ans = j;
				break;
			}
		}
		return ans;
	}

题目二

给你一个字符串 s ，每一次操作你都可以在字符串的任意位置插入任意字符。

请你返回让 s 成为回文串的 最少操作次数 。

来一个dp数组 纵轴是L 横轴是R dp[i][j]表示i...j上需要添加多少字符

每个依赖为: 如果i位置字符等于j位置字符 那么不需要添加 =

如果不等于 那就要看看是在末尾补还是在头部补的操作次数少了

我自己用acbca推了一遍 就是说 当L=0 R=4 的时候怎么求  如果我a==a那就看cbc是怎么变回文的

acb怎么变回文 那就要看ac是怎么变的 cb是怎么变的 在除去开头/结尾的情况下先把它变成回文 然后我们只需要考虑这不是回文的一个字符(就是加上)就可以了

我之前比较困惑的是bab 如果 我在做ba的时候 我直接在后面加了一个b 那我还要也就是变成了bab 已经是回文了 那我这个原本的b怎么处理呢?

如果是bab 在推ba的时候 我们或许会在前面加a 或许会在后面补b 但是如果b==a了 那我们就要看a是怎么变回文串的 而不是ba怎么变的

第三题

一种消息接收并打印的结构设计已知一个消息流会不断地吐出整数1~N,但不一定按照顺序吐出。如果上次打印的数为i，那么当i+1出现时，请打印i+1及其之后接收过的并且连续的所有数，直到1~N全部接收并打印完，请设计这种接收并打印的结构。初始时默认i==0
 

多个空间

比如最开始我们加入  1 3 5 7四个点

那就模拟四个空间

1开头1结尾的

3开头3结尾的

5开头5结尾的

7开头7结尾的

假如说我们来了一个6 它的开头就是6 那我们就去找结尾为5的区间 把他们连在一起

同时维护一个指针 这个指针是指播放到哪个位置了 在哪里卡住了

class Node {
	public String info;
	public Node next;

	public Node(String str) {
		info = str;
	}
}

class Messagebox {
	private HashMap<Integer, Node> headMap;
	private HashMap<Integer, Node> tailMap;
	private int waitPoint;
	
	public Messagebox() {
		headMap = new HashMap<Integer, Node>();
		tailMap = new HashMap<Integer, Node>();
		waitPoint = 1;
	}
	
	public void receive(int num, String info) {
		if (num < 1) {
			return;
		}
		Node cur = new Node(info);

		headMap.put(num, cur);
		tailMap.put(num, cur);
		// 建立了num~num这个连续区间的头和尾
		// 查询有没有某个连续区间以num-1结尾
		if (tailMap.containsKey(num - 1)) {
			tailMap.get(num - 1).next = cur;
			tailMap.remove(num - 1);//如果它能接在某个区间的尾部
			headMap.remove(num);
		}
		// 查询有没有某个连续区间以num+1开头的
		if (headMap.containsKey(num + 1)) {
			cur.next = headMap.get(num + 1);
			tailMap.remove(num);//如果它能接在某个区间的头部
			headMap.remove(num + 1);
		}
		if (num == waitPoint) {
			print();
		}
	}
	
	private void print() {
		Node node = headMap.get(waitPoint);
		headMap.remove(waitPoint);
		while (node != null) {
			System.out.print(node.info + " ");
			node = node.next;
			waitPoint++;
		}
		tailMap.remove(waitPoint-1);
		System.out.println();
	}
}