记录：2022-9-10 完美数快乐数括号生成请求调页页面置换写时复制页面缓冲算法

coderzyc

已于 2022-09-11 14:01:13 修改

阅读量234

点赞数 1

分类专栏：学习日志文章标签：算法 leetcode java

于 2022-09-10 20:09:24 首次发布

本文链接：https://blog.csdn.net/qq_44686225/article/details/126797663

版权

学习日志专栏收录该内容

38 篇文章 0 订阅

订阅专栏

这篇博客探讨了算法优化的策略，包括使用单调队列提升DP问题的效率，例如在解决滑动窗口最大值问题时。此外，还讲解了请求调页和页面置换的概念，详细阐述了缺页处理的过程及其性能影响。文章介绍了写时复制技术，用于在页面共享时避免不必要的副本创建，从而提高效率。最后，讨论了几种页面置换算法，如FIFO、最优页面置换和LRU，并分析了它们的优缺点。

摘要由CSDN通过智能技术生成

学习时间 2022-9-10

学习内容

1、leetcode 两道简单题一道中等题

在这里插入图片描述
优化是靠的退出时机，当除出来的数已经小于除数时，说明后续的已经不需要继续做了，并且如果除出来的余数为0，说明这两个数都是正因子

class Solution {
    public boolean checkPerfectNumber(int num) {
        int ans = 1;
        if(num == 1){
            return false;
        }
        for(int i = 2;i<num;i++){
            int num2 = num / i;
            if(num2 <= i){
                break;
            }
            if(num % i == 0){
                //可以找到两个正因子
                ans += i;
                ans += num2;
            }
        }
        if(ans == num) return true;
        return false;
    }
}

在这里插入图片描述
如果不是快乐数，他在循环的过程中会重复某个值，这就导致他无法回到1

class Solution {
    public boolean isHappy(int n) {
        //中途若出现循环 则结束
        HashSet<Integer> set = new HashSet<Integer>();
        while(n != 1){
            n = getNext(n);
            if(set.contains(n)){
                return false;
            }
            set.add(n);
        }
        return true;
    }
    public int getNext(int n){
        int sum = 0;
        while(n != 0){
            int s1 = n%10;
            sum+=s1*s1;
            n = n/10;
        }
        return sum;
    }
}

在这里插入图片描述
我的解法（暴力枚举）

class Solution {
    public List<String> generateParenthesis(int n) {
        HashSet<String> set = new HashSet<String>();
        set.add("()");
        //滑动窗口
        for(int i = 1;i<n;i++){
            HashSet<String> newSet = new HashSet<String>();
            for(String s : set){
                newSet.add("("+s+")");
                for(int j = 0;j<=s.length();j++){
                    newSet.add(s.substring(0,j)+"()"+s.substring(j,s.length()));
                }
            }
            set = newSet;
        }
        return new ArrayList(set);
    }
}

这个题我更愿意用回溯，因为动态规划的最优子结构不好找不过目前暂时不太会回溯，先贴个答案

class Solution {
        List<String> res = new ArrayList<>();
        public List<String> generateParenthesis(int n) {
            if(n <= 0){
                return res;
            }
            getParenthesis("",n,n);
            return res;
        }

        private void getParenthesis(String str,int left, int right) {
            if(left == 0 && right == 0 ){
                res.add(str);
                return;
            }
            if(left == right){
                //剩余左右括号数相等，下一个只能用左括号
                getParenthesis(str+"(",left-1,right);
            }else if(left < right){
                //剩余左括号小于右括号，下一个可以用左括号也可以用右括号
                if(left > 0){
                    getParenthesis(str+"(",left-1,right);
                }
                getParenthesis(str+")",left,right-1);
            }
        }
    }

2、单调队列优化DP问题

当0<=j<i时，可以用单个变量代替dp数组进行维护
当i-j<=j<=i时（两头变），此时可以使用单调队列维护状态：
假设这个栈是单调减的，头部的元素最大，则可以这样定义：如果头部index过期，则头部出，元素从尾部进，如果他遇到了比进去的元素更小的元素，则可以说明队列中元素不需要了（只需要最大的，如果进的那个元素已经大于队列尾部的元素，说明尾部的元素已经轮不到前面了）
这个解法并不只是在DP中作优化，本身单调队列也可以做一种解法
如滑动窗口最大值问题，就可以用单调队列代替查找，每一次循环将会减少k此循环，从O(mk) -> O(m)