闲着也是闲着，不想刷题了又不知道干什么，还是继续刷吧。
最长递增子序列的个数
题目：给定一个未排序的整数数组，找到最长递增子序列的个数。
示例 1:
输入: [1,3,5,4,7]
输出: 2
解释: 有两个最长递增子序列，分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。
示例 2:
输入: [2,2,2,2,2]
输出: 5
解释: 最长递增子序列的长度是1，并且存在5个子序列的长度为1，因此输出5。
注意: 给定的数组长度不超过 2000 并且结果一定是32位有符号整数。
思路：这个题目的标签是dp。我感觉是有思路的：判断当前元素比之前最长元素的最大值大还是小。如果有大于的，那么条数就是大于的个数。如果都大于则最长的个数还是之前那样（因为每一个都+1了）。如果都小于可能是要判断上上一个的长度，我去仔细想想怎么实现
附上第一版本代码：
class Solution {
public int findNumberOfLIS(int[] nums) {
//每个单词作为最长子串可以的长度
int[] len = new int[nums.length];
int[] count = new int[nums.length];
Arrays.fill(count, 1);
for(int i = 0;i<nums.length;i++) {
for(int j = i+1;j<nums.length;j++) {
if(nums[j]>nums[i]) {//当前元素可以续上nums[i]
if(len[i] == len[j]) {//上一个的长度等于当前的
len[j]++;
count[j] = count[i];
}else if(len[i]+1 == len[j]) {
count[j] += count[i];
}
}
}
}
int max = 0;
for(int i:len) max = Math.max(max, i);
int res = 0;
for(int i = 0;i<nums.length;i++) {
if(len[i] == max) res += count[i];
}
return res;
}
}
虽然性能不咋地但是能做出来就已经很开森了~这里说一下思路：首先这个长度其实是好计算的。只要比上一个数大，就能续上这个长度。所以len表示的是到当前递增子序列的长度，没什么好说的。然后就是这个count不太好计算了。首先i的长度等于j，并且j代表的数字又大于i。说明所有的i都可以续上一个j。所有这里len++。还有就是到i多少种方式，到j就可以多少种方式。
第二个判断是如果到i的长度是到j的-1.说明i往后可以接的j。这样到到j的长度是到i的方式+其自身的方式。所以这里分两种情况。
我思路是一点点debug试出来了。但是上面的代码性能并不好，我去看看题解：
class Solution {
class fwt{
int n;
int[] len;//当前点的递增序列长度
int[] cnt;//方案数
fwt(int n){
this.n = n;
len = new int[n+1];
cnt = new int[n+1];
}
public void add(int x,int len_x,int cnt_x){
//len_x 表示 以当前x为结尾的序列长度，cnt_x为方案数
for(int i=x;i<=n;i+=lowbit(i)){
if(len[i]==len_x)
cnt[i] += cnt_x;
else if(len[i]<len_x){
len[i] = len_x;
cnt[i] = cnt_x;
}
}
}
public int[] query(int x){//返回这个点(x-1)之前的序列长度，和方案数
int len_x = 0;
int cnt_x = 1;
for(int i=x-1;i>=1;i-=lowbit(i)){
//找最长序列
if(len[i]>len_x){
cnt_x = cnt[i];
len_x = len[i];
}
else if(len[i]==len_x)
cnt_x += cnt[i];
}
return new int[]{len_x,cnt_x};
}
public int lowbit(int x){
return x&-x;
}
}
public int findNumberOfLIS(int[] nums) {
int[] t = nums.clone();
int n = t.length;
Arrays.sort(t);
if(t.length<=1)
return t.length;
HashMap<Integer,Integer> map = new HashMap<>();//用于离散化映射
for(int i=1;i<=n;i++) map.put(t[i-1],i);//所有数被映射到[1,n]之间
fwt tree = new fwt(t.length);
for(int num:nums){
int x = map.get(num);
int[] tmp = tree.query(x);//获得x-1之前的序列长度，和方案数
tree.add(x,tmp[0]+1,tmp[1]);//长度要带上x自身
}
return tree.query(n+1)[1];//返回n+1之前的最长方案数即可
}
}
就这个代码行数压倒一切。反正感觉思路差不多，起码都是长度len和方案数count。而且这个什么离散化映射，注解都看不懂，可能这个代码不适合我，下一题了。
实现一个魔法字典
题目：设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于你构建的字典中。
实现 MagicDictionary 类：
MagicDictionary() 初始化对象
void buildDict(String[] dictionary) 使用字符串数组 dictionary 设定该数据结构，dictionary 中的字符串互不相同
bool search(String searchWord) 给定一个字符串 searchWord ，判定能否只将字符串中 一个 字母换成另一个字母，使得所形成的新字符串能够与字典中的任一字符串匹配。如果可以，返回 true ；否则，返回 false 。
示例：
输入
["MagicDictionary", "buildDict", "search", "search", "search", "search"]
[[], [["hello", "leetcode"]], ["hello"], ["hhllo"], ["hell"], ["leetcoded"]]
输出
[null, null, false, true, false, false]
解释
MagicDictionary magicDictionary = new MagicDictionary();
magicDictionary.buildDict(["hello", "leetcode"]);
magicDictionary.search("hello"); // 返回 False
magicDictionary.search("hhllo"); // 将第二个 'h' 替换为 'e' 可以匹配 "hello" ，所以返回 True
magicDictionary.search("hell"); // 返回 False
magicDictionary.search("leetcoded"); // 返回 False
提示：
1 <= dictionary.length <= 100
1 <= dictionary[i].length <= 100
dictionary[i] 仅由小写英文字母组成
dictionary 中的所有字符串 互不相同
1 <= searchWord.length <= 100
searchWord 仅由小写英文字母组成
buildDict 仅在 search 之前调用一次
最多调用 100 次 search
思路：这个题又是一个开放性题目，最坏的不过是把新的字符串一个个比对。我觉得也不是不行。我去试试代码。
这个题一次ac不说，还没有低空略过，有点意思哈，我直接贴代码：
class MagicDictionary {
Map<Integer, List<String>> map;
/** Initialize your data structure here. */
public MagicDictionary() {
map = new HashMap<Integer, List<String>>();
}
public void buildDict(String[] dictionary) {
for(String s:dictionary) {
if(map.get(s.length())==null) {
map.put(s.length(), new ArrayList<String>());
map.get(s.length()).add(s);
}else {
map.get(s.length()).add(s);
}
}
}
public boolean search(String searchWord) {
List<String> list = map.get(searchWord.length());
if(list == null) return false;
for(String s:list) {
if(isOk(searchWord, s)) return true;
}
return false;
}
public boolean isOk(String s,String s1) {
int n = 0;
for(int i = 0;i<s.length();i++) {
if(s.charAt(i) != s1.charAt(i)) {
n++;
if(n>1) return false;
}
}
return n == 1;
}
}
/**
* Your MagicDictionary object will be instantiated and called as such:
* MagicDictionary obj = new MagicDictionary();
* obj.buildDict(dictionary);
* boolean param_2 = obj.search(searchWord);
*/
这里虽然说是暴力对比，但是还有一个小技巧，就是按照字符串的长度分桶了。毕竟长度不一样不可能匹配成功的！而且我刚刚说了上面的代码性能超过百分之九十的人，挺意外的，所以就这样吧，不用树来树去的挺好的，下一题了。
键值映射
题目：实现一个 MapSum 类，支持两个方法，insert 和 sum：
MapSum() 初始化 MapSum 对象
void insert(String key, int val) 插入 key-val 键值对，字符串表示键 key ，整数表示值 val 。如果键 key 已经存在，那么原来的键值对将被替代成新的键值对。
int sum(string prefix) 返回所有以该前缀 prefix 开头的键 key 的值的总和。
示例：
输入：
["MapSum", "insert", "sum", "insert", "sum"]
[[], ["apple", 3], ["ap"], ["app", 2], ["ap"]]
输出：
[null, null, 3, null, 5]
解释：
MapSum mapSum = new MapSum();
mapSum.insert("apple", 3);
mapSum.sum("ap"); // return 3 (apple = 3)
mapSum.insert("app", 2);
mapSum.sum("ap"); // return 5 (apple + app = 3 + 2 = 5)
提示：
1 <= key.length, prefix.length <= 50
key 和 prefix 仅由小写英文字母组成
1 <= val <= 1000
最多调用 50 次 insert 和 sum
思路：这个题怎么说呢，只能说躲不过的前缀树。上一题逃过去了这一题补上。用前缀树的方式k存字母。v存值。有v存v没有就是0。反正思路是挺清晰的，我去实现下吧
又是一次过，我先贴代码：
class MapSum {
PreTree tree;
/** Initialize your data structure here. */
public MapSum() {
tree = new PreTree();
}
public void insert(String key, int val) {
PreTree cur = tree;
for (char c : key.toCharArray()) {
if (cur.children[c - 'a'] != null) {
cur = cur.children[c - 'a'];
} else {
cur.children[c - 'a'] = new PreTree();
cur = cur.children[c - 'a'];
}
}
cur.val = val;
}
int res;
public int sum(String prefix) {
PreTree cur = tree;
for(char c : prefix.toCharArray()) {
if (cur.children[c - 'a'] != null) {
cur = cur.children[c - 'a'];
} else {
return 0;
}
}
res = 0;
sumRes(cur);
return res;
}
public void sumRes(PreTree tree) {
res += tree.val;
for(int i = 0;i<26;i++) {
if(tree.children[i]!=null) sumRes(tree.children[i]);
}
}
}
class PreTree {
int val;
PreTree[] children;
public PreTree() {
val = 0;
children = new PreTree[26];
}
}
/**
* Your MapSum object will be instantiated and called as such:
* MapSum obj = new MapSum();
* obj.insert(key,val);
* int param_2 = obj.sum(prefix);
*/
代码挺简单的，思路就是前缀树没啥好说的，然后性能一如既往的不好我也不知道为啥。。刚刚看了性能比较好的代码，感觉不是hash映射就是前缀树，所以这里也不多说什么了，下一题。
有效的括号字符串
题目:给定一个只包含三种字符的字符串：（ ，） 和 *，写一个函数来检验这个字符串是否为有效字符串。有效字符串具有如下规则：
任何左括号 ( 必须有相应的右括号 )。
任何右括号 ) 必须有相应的左括号 ( 。
左括号 ( 必须在对应的右括号之前 )。
* 可以被视为单个右括号 ) ，或单个左括号 ( ，或一个空字符串。
一个空字符串也被视为有效字符串。
示例 1:
输入: "()"
输出: True
示例 2:
输入: "()"
输出: True
示例 3:
输入: "())"
输出: True
注意:
字符串大小将在 [1，100] 范围内。
思路：这个题乍一审题我就觉得应该不难，从前往后遍历，左括号和万能符记录。如果出现了右括号前面没有对应的左括号或者万能符则false，否则true
这个在做的时候才发现应该是个双向判断，毕竟左括号要有对应的右括号，同理右括号有对应的左括号才可以。反正如下代码:
class Solution {
public boolean checkValidString(String s) {
int left = 0;
int right = 0;
int all = 0;
char[] arr = s.toCharArray();
for(int i = 0;i<arr.length;i++) {
if(arr[i]=='*') {
all++;
}else if(arr[i]=='(') {
left++;
}else {//到这里说明是右括号，判断后面有没有对应的左括号
if(left>0) {
left--;
}else if(all>0) {
all--;
}else {//这个右括号前面没东西了。所以false
return false;
}
}
}
all = 0;
for(int i = arr.length-1;i>=0;i--) {
if(arr[i]=='*') {
all++;
}else if(arr[i]==')') {
right++;
}else {//到这里说明是左括号，判断后面有没有对应的右括号
if(right>0) {
right--;
}else if(all>0) {
all--;
}else {//这个左括号后面没东西了。所以false
return false;
}
}
}
return true;
}
}
我是觉得思路挺简单的，而且性能超过百分百，我去看下官方题解，没啥问题就过了。官方题解果然做到了眼中无码心中有码的地步，就简单说了几个思路莫得代码实现。反正这个题是三种解法：dp，贪心，暴力。
我也不清楚我这个属于什么，反正不是暴力法，毕竟时间复杂度算是O(n)（2n也算n）。所以直接下一题了。
分发糖果
题目：老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。你需要按照以下要求，帮助老师给这些孩子分发糖果：
每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？
示例 1:
输入: [1,0,2]
输出: 5
解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。
示例 2:
输入: [1,2,2]
输出: 4
解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。
思路：这个题是今天的每日一题。我目前的想法就是从头往后遍历。第一个肯定是1.如果遇到后面的小于当前的。则当前的顺序+1给后面的腾糖果数。这个顺序加是指当前的，比当前更大的算是一条线。当遇到小于等于当前值的这条线就算了。反正是有点思路，我去实现下试试。
调试了一个多小时总算ac了，先贴代码:
class Solution {
public int candy(int[] ratings) {
if(ratings.length<1) return 0;
int[] suger = new int[ratings.length];
suger[0] = 1;
for(int i = 1;i<ratings.length;i++) {
//当前小于上一个,当前一定是1.然后判断上面要修改多少个
if(ratings[i]<=ratings[i-1]) {
suger[i] = 1;
//如果是等于则不用管
if(ratings[i]<ratings[i-1] && suger[i-1]==1) {
//上一个元素一定是1，所以要递增往上加
int temp = i-1;
suger[temp]++;//上一个赋值2.这样这个才能是1.
//要把上一个的上一个统一增加.如果上一个成绩大于当前并且当前增加后等于上一个了则上一个也要对应增加
while(temp>0 && ratings[temp]<ratings[temp-1] && suger[temp]==suger[temp-1]) {
suger[--temp]++;
}
}
}else {//当前大于上一个，上一个基础上增加
suger[i] = suger[i-1]+1;
}
}
int res = 0;
for(int i:suger) res += i;
return res;
}
}
简单说下思路,虽然上面代码性能不咋地但是我觉得我还是挺自豪的。毕竟这个题的难度等级是困难。其实这个思路就是遇到比当前小的先用1补上（因为1个糖果是最少的花销了）。然后下一个如果还比这个小，说明下一个要是1.根据要求当前的必须大于下一个，所以当前要+1.同理比当前顺序大的也都要+1.反正总而言之这个题的思路就是这样。只不过我这个代码的处理上可能不太好。这里我之前想过用栈了，但是不确定思路所以这里先这么实现了， 起码确定思路正确才好开始用各种数据结构简化。不过我觉得我这种方式不应该性能这么差啊，我去看看官方的思路和题解了：
class Solution {
public int candy(int[] ratings) {
int n = ratings.length;
int[] left = new int[n];
for (int i = 0; i < n; i++) {
if (i > 0 && ratings[i] > ratings[i - 1]) {
left[i] = left[i - 1] + 1;
} else {
left[i] = 1;
}
}
int right = 0, ret = 0;
for (int i = n - 1; i >= 0; i--) {
if (i < n - 1 && ratings[i] > ratings[i + 1]) {
right++;
} else {
right = 1;
}
ret += Math.max(left[i], right);
}
return ret;
}
}
官方题解中的代码。简单来说是两次遍历。左到右，右到左。以两次遍历值较大的为准。思路比较好理解，而且代码也更直观，就这样吧，这个题感觉比有个中等的题都简单。。。下一题了。
买卖股票的最佳时机4
题目：给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
示例 2：
输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
提示：
0 <= k <= 109
0 <= prices.length <= 1000
0 <= prices[i] <= 1000
思路：买卖股票的题几乎都是典型的dp。而且之前不久做了个没有k的，就是把每天买入卖出记录顺序往下顺。那个就是压状dp。这个题就多了个k，但是实现起来没啥思路，我再想想
先贴代码:
class Solution {
public int maxProfit(int k, int[] prices) {
if(prices.length == 0) return 0;
//一买一卖，如果k大于天数的一半说明随便交易
if (k >= prices.length / 2) {
int sell = 0;
int buy = -prices[0];
// 每天留手里和卖掉
for (int i = 1; i < prices.length; i++) {
sell = Math.max(buy + prices[i], sell);
buy = Math.max(sell - prices[i], buy);
}
return sell;
}
int[] sell = new int[k + 1];
int[] buy = new int[k + 1];
sell[0] = 0;
buy[0] = -prices[0];
// 每天留手里和卖掉被压缩成上一次的值了。
// 这里的数组下表表示当前元素作为第n比交易的结果
for (int i = 1; i <= k; i++) {
buy[i] = sell[i] = Integer.MIN_VALUE / 2;
}
for (int i = 1; i < prices.length; i++) {
//buy-0是买今天的股。所以上一次的卖出-今天的价格
buy[0] = Math.max(buy[0], sell[0]-prices[i]);
for (int j = 1; j <= k; j++) {
buy[j] = Math.max(buy[j], sell[j]-prices[i]);
sell[j] = Math.max(buy[j-1]+prices[i], sell[j]);
}
}
return sell[k];
}
}
我只能说看官方题解都没咋看懂。琢磨了一下午才算是明白了，总而言之把每一个元素都作为第1，2，3，....k比交易进行记录，获取其第k比交易的最大值。就是如上的思路，每个元素都1-k比交易顺序判断，这样的好处是保证每一笔交易都是当前笔数的最大值。所以第k比就是k比的最大值。其实这里我觉得比较绕，但是理解了会豁然开朗。反正我觉得我把我想的都写在注释里了。这个题也就这样吧。最后一题。
“马”在棋盘上的概率
题目：已知一个 NxN 的国际象棋棋盘，棋盘的行号和列号都是从 0 开始。即最左上角的格子记为 (0, 0)，最右下角的记为 (N-1, N-1)。 现有一个 “马”（也译作 “骑士”）位于 (r, c) ，并打算进行 K 次移动。 如下图所示，国际象棋的 “马” 每一步先沿水平或垂直方向移动 2 个格子，然后向与之相垂直的方向再移动 1 个格子，共有 8 个可选的位置。
现在 “马” 每一步都从可选的位置（包括棋盘外部的）中独立随机地选择一个进行移动，直到移动了 K 次或跳到了棋盘外面。求移动结束后，“马” 仍留在棋盘上的概率。
示例：
输入: 3, 2, 0, 0
输出: 0.0625
解释:
输入的数据依次为 N, K, r, c
第 1 步时，有且只有 2 种走法令 “马” 可以留在棋盘上（跳到（1,2）或（2,1））。对于以上的两种情况，各自在第2步均有且只有2种走法令 “马” 仍然留在棋盘上。
所以 “马” 在结束后仍在棋盘上的概率为 0.0625。
注意：
N 的取值范围为 [1, 25]
K 的取值范围为 [0, 100]
开始时，“马” 总是位于棋盘上
思路：总而言之就是一个几率学呗？第一次3/8的几率。如果这个三个分别是1/2.3/8.1/4.那么就是分别乘3/8相加。总几率就是在场上的概率。如果算法没错的话就这么一层一层递归实现。我去合计一下是不是这么算的。
差不多的思路，超时的死去活来中一点点优化，先贴代码：
class Solution {
double[][][] memo;
List<int[]> choice = new ArrayList<>();
public double knightProbability(int N, int K, int r, int c) {
choice.add(new int[]{1, 2});choice.add(new int[]{1, -2});
choice.add(new int[]{-1, 2});choice.add(new int[]{-1, -2});
choice.add(new int[]{2, 1});choice.add(new int[]{2, -1});
choice.add(new int[]{-2, 1});choice.add(new int[]{-2, -1});
memo = new double[N][N][K+1];
return dp(r, c, N, K);
}
public double dp(int i, int j, int N, int K) {
//越界直接是0
if(i < 0 || j < 0 || i >= N || j >= N) return 0;
//满足条件
if(K == 0) return 1.0d;
//有记录直接使用
if(memo[i][j][K] != 0) return memo[i][j][K];
double ans = 0.0;
//dfs搜索八个分支
for(int[] cur : choice) ans += dp(i+cur[0], j+cur[1], N, K-1);
memo[i][j][K] = ans/8;
return ans/8;
}
}
简单来说我这其实就是暴力法。只不过会有个记忆操作。一层一层往下找，直到结束。这里其实就是一个递归。一层一层往下找，遇到有记忆的直接用结果而不是重复算。总而言之这个题我感觉应该是有什么算法的，但是我就是暴力递归+备忘录解的。。。我去看看性能第一的代码：
好像是大同小异，我先贴代码：
class Solution {
int[][] dirs = new int[][] {{2, 1}, {1, 2}, {-1, 2}, {-2, 1}, {-2, -1}, {-1, -2}, {1, -2}, {2, -1}};
Double[][][] dp;
public double knightProbability(int N, int K, int r, int c) {
dp = new Double[N / 2 + 1][N / 2 + 1][K + 1];
return helper(N, K, r, c);
}
private double helper(int N, int K, int r, int c) {
if (r < 0 || r >= N || c < 0 || c >= N) return 0.0;
if (K == 0) return 1.0;
r = Math.min(r, N - r - 1);
c = Math.min(c, N - c - 1);
if (dp[r][c][K] != null) return dp[r][c][K];
double sum = 0.0;
for (int[] dir: dirs) {
sum += helper(N, K - 1, r + dir[0], c + dir[1]);
}
return dp[r][c][K] = sum * 0.125;
}
}
我这里用的集合，人家用的数组。我这里用来记录的三维数组是长宽为N的数组。但是人家的长宽是N/2+1。我感觉重点就应该是这里性能优化的，但是为什么这么实现有点不清楚。刚刚群里问了下应该是做了对称。就是左上角等于右下角。。折叠折叠出的结果？反正不确定，这个题就这样了，不纠结了。
本篇笔记就记到这里，如果稍微帮到你了记得点个喜欢点个关注，也祝大家工作顺顺利利！
