Java实现 184 LeetCode周赛

5380.数组中的字符串匹配
给你一个字符串数组 words ，数组中的每个字符串都可以看作是一个单词。请你按 任意 顺序返回 words 中是其他单词的子字符串的所有单词。

如果你可以删除 words[j] 最左侧和/或最右侧的若干字符得到 word[i] ，那么字符串 words[i] 就是 words[j] 的一个子字符串。

示例 1：

输入：words = [“mass”,“as”,“hero”,“superhero”]
输出：[“as”,“hero”]
解释：“as” 是 “mass” 的子字符串，“hero” 是 “superhero” 的子字符串。
[“hero”,“as”] 也是有效的答案。
示例 2：

输入：words = [“leetcode”,“et”,“code”]
输出：[“et”,“code”]
解释：“et” 和 “code” 都是 “leetcode” 的子字符串。
示例 3：

输入：words = [“blue”,“green”,“bu”]
输出：[]

提示：

1 <= words.length <= 100
1 <= words[i].length <= 30
words[i] 仅包含小写英文字母。
题目数据 保证 每个 words[i] 都是独一无二的。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/string-matching-in-an-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public List stringMatching(String[] words) {
        List list = new ArrayList();
		
		for(int i = 0; i < words.length-1; i++) {
			for(int j = i+1; j < words.length; j++) {
				if(words[i].contains(words[j]) && !list.contains(words[j])) {
					list.add(words[j]);
				}else if( words[j].contains(words[i]) && !list.contains(words[i])) {
					list.add(words[i]);
				}
			}
		}
		return list;
    }
}

5381.查询带键的排列
给你一个待查数组 queries ，数组中的元素为 1 到 m 之间的正整数。 请你根据以下规则处理所有待查项 queries[i]（从 i=0 到 i=queries.length-1）：

一开始，排列 P=[1,2,3,…,m]。
对于当前的 i ，请你找出待查项 queries[i] 在排列 P 中的位置（下标从 0 开始），然后将其从原位置移动到排列 P 的起始位置（即下标为 0 处）。注意， queries[i] 在 P 中的位置就是 queries[i] 的查询结果。
请你以数组形式返回待查数组 queries 的查询结果。

示例 1：

输入：queries = [3,1,2,1], m = 5
输出：[2,1,2,1]
解释：待查数组 queries 处理如下：
对于 i=0: queries[i]=3, P=[1,2,3,4,5], 3 在 P 中的位置是 2，接着我们把 3 移动到 P 的起始位置，得到 P=[3,1,2,4,5] 。
对于 i=1: queries[i]=1, P=[3,1,2,4,5], 1 在 P 中的位置是 1，接着我们把 1 移动到 P 的起始位置，得到 P=[1,3,2,4,5] 。
对于 i=2: queries[i]=2, P=[1,3,2,4,5], 2 在 P 中的位置是 2，接着我们把 2 移动到 P 的起始位置，得到 P=[2,1,3,4,5] 。
对于 i=3: queries[i]=1, P=[2,1,3,4,5], 1 在 P 中的位置是 1，接着我们把 1 移动到 P 的起始位置，得到 P=[1,2,3,4,5] 。
因此，返回的结果数组为 [2,1,2,1] 。
示例 2：

输入：queries = [4,1,2,2], m = 4
输出：[3,1,2,0]
示例 3：

输入：queries = [7,5,5,8,3], m = 8
输出：[6,5,0,7,5]

提示：

1 <= m <= 10^3
1 <= queries.length <= m
1 <= queries[i] <= m

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/queries-on-a-permutation-with-key
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

总结这题出现的问题：经验太少了，犯过的错没有思考清楚，思维不够严谨。
这题在做的时候又出现了审题上的思维漏洞，要将数字移到起始位置，最开始一直理解错了，直接将该数字与头位置的数字交换了位置；另外这题在对queries中的一个数字处理完后就要跳出p的循环，处理queries的下一个数，不然就会出现错误，因为新的数字可能会跟后面的数字相匹配，经常在这里出错。

class Solution {
    public int[] processQueries(int[] queries, int m) {
         int p[] = new int[m];
		 for(int i = 0; i < p.length; i++) {
			 p[i] = i+1;
		 }
		 for(int i = 0; i < queries.length; i++) {
			 for(int j = 0; j < p.length; j++) {
				 if(p[j] == queries[i]) {
					 queries[i] = j;//是移到起始位置不是交换
					 
					 int index = j;
					 int temp = p[j];
					 while(index > 0) {
						 p[index] = p[index-1];
						 index--;
					 }
					 p[0] = temp;
					 break;
				 }
			 }
		 }
		 return queries;
    }
}

5383.HTML 实体解析器
「HTML 实体解析器」 是一种特殊的解析器，它将 HTML 代码作为输入，并用字符本身替换掉所有这些特殊的字符实体。

HTML 里这些特殊字符和它们对应的字符实体包括：

双引号：字符实体为 " ，对应的字符是 " 。
单引号：字符实体为 ’ ，对应的字符是 ’ 。
与符号：字符实体为 & ，对应对的字符是 & 。
大于号：字符实体为 > ，对应的字符是 > 。
小于号：字符实体为 < ，对应的字符是 < 。
斜线号：字符实体为 ⁄ ，对应的字符是 / 。
给你输入字符串 text ，请你实现一个 HTML 实体解析器，返回解析器解析后的结果。

示例 1：

输入：text = “& is an HTML entity but &ambassador; is not.”
输出："& is an HTML entity but &ambassador; is not."
解释：解析器把字符实体 & 用 & 替换
示例 2：

输入：text = “and I quote: “…””
输出：“and I quote: “…””
示例 3：

输入：text = “Stay home! Practice on Leetcode ”
输出：“Stay home! Practice on Leetcode ”
示例 4：

输入：text = “x > y && x < y is always false”
输出：“x > y && x < y is always false”
示例 5：

输入：text = “leetcode.com⁄problemset⁄all”
输出：“leetcode.com/problemset/all”

提示：

1 <= text.length <= 10^5
字符串可能包含 256 个ASCII 字符中的任意字符。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/html-entity-parser
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这题反思：这题很尴尬，我忘记怎么将单引号双引号隔开了,再加上我开始一直纠结用正则表达式切割字符串（唉，还不是基础不扎实对啥都懵懵懂懂的，会在这周把正则表达式过关，也就是记一记的事吧）
最后的做法好像啰嗦了，然后精简一下吧

class Solution {
    public String entityParser(String text) {
        String[] HTML = new String[6];
		HTML[0] = """;
		HTML[1] = "'";
		HTML[2] = "&";
		HTML[3] = ">";
		HTML[4] = "<";
		HTML[5] = "⁄";
		String m[] = new String[6];
		m[0] = "\"";
		m[1] = "\'";
		m[2] = "&";
		m[3] = ">";
		m[4] = "<";
		m[5] = "/";
		
		for(int i = 0; i < HTML.length; i++) {
			if(text.contains(HTML[i])) {
				text = text.replaceAll(HTML[i], m[i]);
			}
		}
		
		return text;
    }
}

//把无用功去掉了
class Solution {
    public String entityParser(String text) {
       text = text.replaceAll(""","\"").replaceAll("'","\'").replaceAll("&","&").replaceAll("<","<").replaceAll(">",">").replaceAll("⁄","/");
       return text;
    }
}

5383.给N×3网络涂色的方案数
你有一个 n x 3 的网格图 grid ，你需要用 红，黄，绿 三种颜色之一给每一个格子上色，且确保相邻格子颜色不同（也就是有相同水平边或者垂直边的格子颜色不同）。

给你网格图的行数 n 。

请你返回给 grid 涂色的方案数。由于答案可能会非常大，请你返回答案对 10^9 + 7 取余的结果。

示例 1：

输入：n = 1
输出：12
解释：总共有 12 种可行的方法：

示例 2：

输入：n = 2
输出：54
示例 3：

输入：n = 3
输出：246
示例 4：

输入：n = 7
输出：106494
示例 5：

输入：n = 5000
输出：30228214

提示：

n == grid.length
grid[i].length == 3
1 <= n <= 5000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-ways-to-paint-n-x-3-grid
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这题看到题的一般反应就是动态规划吧，但是我现在的水平自然没想出来，有大佬第一反应就是数学问题，唉，看看跟人家差距。
两种情况：
ABC的下一行可以是：两种颜色的BAB BCB 三种颜色的 BCA CAB ->2 2
ABA的下一行可以是：两种颜色的BCB CAC BAB三种颜色的 CAB BAC -> 3 2
dp[i][0]:表示上一种情况为ABA
dp[i][1]:表示上一种情况为ABC
最后两种情况相加即可
dp[0]：表示1*3的情况，也就是题上的第一种样例：dp[0][0] 有6种 dp[0][1] 有6种

class Solution {
    public int numOfWays(int n) {
        long[][] dp = new long[n][2];
		dp[0][0] = 6;
		dp[0][1] = 6;
		int MOD = 1000000007;
		for(int i = 1; i < n; i++) {
			dp[i][0] = (dp[i-1][0]*3 + dp[i-1][1]*2)%MOD;
			dp[i][1] = (dp[i-1][0]*2 + dp[i-1][1]*2)%MOD;
		}
		return (int)((dp[n-1][0]+dp[n-1][1])%MOD);
    }
}

总结：不足之处：动态规划，基础，题的敏感度不行（也就是题量的积累太少），一切的一切就是菜！