这两天项目迁移，新开了个redis的container，但是实际发现项目有bug，token设置的24小时过期，但是竟然五分钟就过期了，镜像是拉别人的，默认配置，具体不知道是不是这个问题，先查询是不是客户端执行的命令有问题

```
127.0.0.1:6379> info commandstats 

cmdstat_flushall:calls=2,usec=9,usec_per_call=4.50
cmdstat_setex:calls=2,usec=9,usec_per_call=4.50
cmdstat_hset:calls=1,usec=4,usec_per_call=4.00
cmdstat_select:calls=4,usec=5,usec_per_call=1.25
cmdstat_keys:calls=2,usec=18,usec_per_call=9.00
cmdstat_ping:calls=4,usec=3,usec_per_call=0.75
cmdstat_flushdb:calls=1,usec=20,usec_per_call=20.00
cmdstat_info:calls=7,usec=505,usec_per_call=72.14
cmdstat_config:calls=1,usec=6,usec_per_call=6.00 

```

发现会大概五分钟执行一次flushall，难怪，换了个镜像配置了一下，问题解决


又出现了这个问题.....依然是flushall,为什么为什么为什么，我之前怀疑过这个可能但是觉得可能性很小毕竟只是听过，那就是中病毒了，之前看那一堆key,还以为是默认的，没仔细看，好家伙我还以为我鉴权逻辑有问题，修bug修了这么久

正确答案是！中病毒了，对的，一种叫redis扩散病毒的病毒，在你redis插入backup1...backup4,四个键值对每个都是一个curl命令，作用就是在国外服务器下载一个sh脚本执行，我滴妈呀！根据经历过的博主测评，所有脚本定时执行执行之后会对防火墙进程linux重要文件进行删除，删除之后基本就是废了，幸好我在container环境运行，没有造成严重后果


真相大白，解决办法就是设置密码就好了


https://juejin.cn/post/7195199519624003642

记一次redis错误

后端太难找了，学学前端
总结一下学习文章，直接上手得有点不懂

[块级标签靠右显示](https://juejin.cn/post/6985480302030225415)



uniapp学习


![image.png](/static/img/5e39f6e741ab1754cb82597f54dd8720.image.webp)

```java
class Solution {
    public int tribonacci(int n) {
        if (n == 0) return 0;
        if (n == 1 || n == 2) return 1;

        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 1;

        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        }

        return dp[n];
    }
}
````

![image.png](/static/img/b4c9d8dc97f3b4810536fdbb2d2aa7eb.image.webp)


```java
class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        
        for (int i = 2; i < n; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        
        return dp[n - 1];
    }

}
```



![image.png](/static/img/4b04702b1e8a7bd8111a22f824c849d2.image.webp)

```java
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        int[] dp = new int[n];
        
        // 初始化dp数组为三角形的最后一行
        for (int i = 0; i < n; i++) {
            dp[i] = triangle.get(n - 1).get(i);
        }
        
        // 从三角形的倒数第二行开始向上计算
        for (int i = n - 2; i >= 0; i--) {
            for (int j = 0; j <= i; j++) {
                // 状态转移方程
                dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
            }
        }
        
        // dp[0] 就是从顶部到底部的最小路径和
        return dp[0];
    }
}
```

今日刷题


![image.png](/static/img/c1831ee52daa441ecf1bd6d3da4c7913.image.webp)

```java

// 这是我乱搞的答案
class Solution {
    public int minimumRounds(int[] tasks) {
        int size = tasks.length + 1;
        int[] mid = new int[10000001];
        
        for(int i : tasks) {
            mid[i % mid.length]++;
        } 

   
        int res = 0;
        // System.out.println(mid[2]);
        for(int x : mid) {
            if(x == 1) {
                return -1;
            }
            
            if(x % 3 == 0) {
                res += (x/3);
            }else if(x % 3 == 1) {
                res += (x/3);
                res++;
            }else if(x % 3 == 2) {
                res += (x/3);
                res++;
            }

            
        }

        return res;
    }
}

//
public class Solution {
    public int minimumRounds(int[] tasks) {
        // 使用HashMap来统计每个难度级别的任务数量
        Map<Integer, Integer> taskCounts = new HashMap<>();
        for (int task : tasks) {
            taskCounts.put(task, taskCounts.getOrDefault(task, 0) + 1);
        }

        // 将HashMap中的元素转移到一个列表中，并根据任务数量对列表进行排序
        List<Map.Entry<Integer, Integer>> sortedEntries = new ArrayList<>(taskCounts.entrySet());
        sortedEntries.sort((a, b) -> b.getValue() - a.getValue());

        int rounds = 0;
        // 遍历排序后的列表
        for (Map.Entry<Integer, Integer> entry : sortedEntries) {
            int count = entry.getValue();
            // 如果任务数量为1，则无法完成，返回-1
            if (count == 1) {
                return -1;
            }
            // 计算完成当前难度级别任务所需的轮数
            rounds += (count + 2) / 3;
        }

        return rounds;
    }
}




```


![image.png](/static/img/b65cb9326a2a647aac8452e1f165514b.image.webp)

```java
public class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 使用HashMap来记录每个元素出现的频率
        Map<Integer, Integer> frequencyMap = new HashMap<>();
        for (int num : nums) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }

        // 创建一个最小堆来存储元素及其频率
        PriorityQueue<Map.Entry<Integer, Integer>> minHeap = new PriorityQueue<>(
                Map.Entry.comparingByValue()
        );

        // 遍历HashMap，将元素及其频率添加到最小堆中
        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
            minHeap.offer(entry);
            if (minHeap.size() > k) {
                minHeap.poll(); // 如果堆的大小超过k，移除堆顶元素
            }
        }

        // 从最小堆中取出所有元素，这些元素就是出现频率前k高的元素
        int[] result = new int[k];
        for (int i = 0; i < k; i++) {
            result[i] = minHeap.poll().getKey();
        }
        return result;
    }
}

```



![image.png](/static/img/ed6e8d4972897dceb7a6b78f43d15100.image.webp)

```java
class Solution {
    public char findTheDifference(String s, String t) {
        int[] mid1 = new int[128];
        int[] mid2 = new int[128];
        char res = ' ';
        for(char a : s.toCharArray()) {
            mid1[a] ++;
        }

        for(char a : t.toCharArray()) {
            // 
            mid2[a] ++;
        }

        for(int i = 0;i < 128;i++) {
            if(mid1[i] != mid2[i]) {
                res = (char)i;
            }
        }

        return res;
    }
}

public class Solution {
    public char findTheDifference(String s, String t) {
        int[] charCount = new int[26];
        // 计算s中每个字母的出现次数
        for (int i = 0; i < s.length(); i++) {
            charCount[s.charAt(i) - 'a']++;
        }
        // 减去t中每个字母的出现次数
        for (int i = 0; i < t.length(); i++) {
            charCount[t.charAt(i) - 'a']--;
        }
        // 找到第一个计数不为0的字母
        for (int i = 0; i < charCount.length; i++) {
            if (charCount[i] != 0) {
                return (char) (i + 'a');
            }
        }
        return ' '; // 如果没有找到，返回一个空格字符
    }
}


```



![image.png](/static/img/d0b1c14a3b9c8a1a9cb9743c78a836f0.image.webp)

```java
public class Solution {
    public String multiply(String num1, String num2) {
         if (num1.equals("0") || num2.equals("0")) {
             return "0";
           }

         int[] result = new int[num1.length() + num2.length()];

         for (int i = num1.length() - 1; i >= 0; i--) {
              for (int j = num2.length() - 1; j >= 0; j--) {
                   int mul = (num1.charAt(i) - '0') * (num2.charAt(j) - '0');
                   int p1 = i + j, p2 = i + j + 1;
                   int sum = mul + result[p2];

                   result[p2] = sum % 10;
                   result[p1] += sum / 10;
               }
           }

         StringBuilder sb = new StringBuilder();
          for (int i = 0; i < result.length; i++) {
               if (i == 0 && result[i] == 0) {
                   continue;
               }
               sb.append(result[i]);
           }

          return sb.toString();
       }
}


```



![image.png](/static/img/7817fb7a3e548bdb3680ad73ec9b5980.image.webp)

```java
public class Solution {
    public String[] findRestaurant(String[] list1, String[] list2) {
         Map<String, Integer> indexMap = new HashMap<>();
         for (int i = 0; i < list1.length; i++) {
              indexMap.put(list1[i], i);
          }

         int minIndexSum = Integer.MAX_VALUE;
         List<String> commonRestaurants = new ArrayList<>();

         for (int i = 0; i < list2.length; i++) {
              if (indexMap.containsKey(list2[i])) { // 共同爱好
                  int indexSum = i + indexMap.get(list2[i]); // 计算索引和
                  if (indexSum < minIndexSum) { //是否是最小索引和
                      minIndexSum = indexSum;
                       commonRestaurants.clear();
                       commonRestaurants.add(list2[i]);
                   } else if (indexSum == minIndexSum) {
                       commonRestaurants.add(list2[i]);
                   }
               }
           }
        return commonRestaurants.toArray(new String[0]);
         //return commonRestaurants.toArray(new String[0]);
       }
}


```



![image.png](/static/img/d70e27c05e307837cd9eff227e3cd85f.image.webp)

```java
public class Solution {
    public int coinChange(int[] coins, int amount) {
          // 初始化一个比amount大的数，表示无法凑成的金额
          int max = amount + 1;
          // 初始化dp数组，所有值设为最大值
          int[] dp = new int[amount + 1];
          Arrays.fill(dp, max);
          // 金额为0时，不需要任何硬币
          dp[0] = 0;

          // 遍历所有金额
          for (int i = 1; i <= amount; i++) {
               // 遍历所有硬币
               for (int coin : coins) {
                    // 如果当前金额大于等于硬币面值
                    if (i >= coin) {
                         // 更新dp[i]为dp[i]和dp[i - coin] + 1的最小值
                         dp[i] = Math.min(dp[i], dp[i - coin] + 1);
                    }
               }
          }

          // 如果dp[amount]没有被更新过，说明无法凑成该金额
          return dp[amount] == max ? -1 : dp[amount];
      }
}






```


