【LeetCode】Sama的个人记录_76

在遍历过程中同时维护"最小值"和"第二最小值"即可实现O(1)的空间与O(n)的时间

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int min = Integer.MAX_VALUE;
        int mid = Integer.MAX_VALUE;
        for (int num : nums) {
            if (num <= min) {
                min = num;
            } else if (num <= mid) {
                mid = num;
            } else {
                return true;
            }
        }     
        return false;
    }
}

 
 

蓄水池抽样算法————在未知长度的流式数据中随机抽样！

流数据开始带来...
当前第1个数字到来，拿第1个数的概率是100%
当前第2个数字到来，拿第2个数的概率是50%，保留原来拿的数字的概率是50%
当前第3个数字到来，拿第3个数的概率是33%，保留原来拿的数字的概率是66%
当前第4个数字到来，拿第4个数的概率是25%，保留原来拿的数字的概率是75%
最后拿的/保留的数字即为随机取样...

注意：此过程中设置一个递增的cnt变量，用于生成1/2、1/3、1/4...即拿当前数字替换原来数字的概率。

class Solution {

    private ListNode head;
    private Random random;

    public Solution(ListNode head) {
        this.head = head;
        this.random = new Random();
    }
    
    public int getRandom() {
        ListNode node = head;
        int res = 0;
        int cnt = 1;
        while (node != null) {
            // new Random().nextInt(n)的返回值为[0,n)的随机整数
            if (random.nextInt(cnt) == 0) {
                res = node.val;
            }
            cnt++;
            node = node.next;
        }
        return res;
    }
}

 
 

一个经典而有趣的动态规划。

a的下一个只能是e
e的下一个只能是a或i
i的下一个不能是i
o的下一个只能是i或u
u的下一个只能是a
↓
ae、ea、ei、ia、ie、io、iu、oi、ou、ua
↓
a的前一个只能是e或i或u
e的前一个只能是a或i
i的前一个只能是e或o
o的前一个只能是i
u的前一个只能是i或o

设dp[i][j]的含义是，以i结尾的长度为j的串的种类的个数，代码呼之欲出！

class Solution {
    public int countVowelPermutation(int n) {
        long mod = 1000000007;
        long[][] dp = new long[5][n + 1];
        for (int i = 0; i < 5; i++) {
            dp[i][1] = 1;
        }
        for (int j = 2; j <= n; j++) {
            dp[0][j] = (dp[1][j - 1] + dp[2][j - 1] + dp[4][j - 1]) % mod;
            dp[1][j] = (dp[0][j - 1] + dp[2][j - 1]) % mod;
            dp[2][j] = (dp[1][j - 1] + dp[3][j - 1]) % mod;
            dp[3][j] = (dp[2][j - 1]) % mod;
            dp[4][j] = (dp[2][j - 1] + dp[3][j - 1]) % mod;
        }
        long res = 0;
        for (int i = 0; i < 5; i++) {
            res = (res + dp[i][n]) % mod;
        }
        return (int) res;
    }
}

class Solution {
    public int countVowelPermutation(int n) {
    	// 降维优化(注意暂存)
        long mod = 1000000007;
        long[] dp = new long[5];
        for (int i = 0; i < 5; i++) {
            dp[i] = 1;
        }
        for (int j = 2; j <= n; j++) {
            long a = (dp[1] + dp[2] + dp[4]) % mod;
            long e = (dp[0] + dp[2]) % mod;
            long i = (dp[1] + dp[3]) % mod;
            long o = (dp[2]) % mod;
            long u = (dp[2] + dp[3]) % mod;
            dp[0] = a;
            dp[1] = e;
            dp[2] = i;
            dp[3] = o;
            dp[4] = u;
        }
        long res = 0;
        for (int i = 0; i < 5; i++) {
            res = (res + dp[i]) % mod;
        }
        return (int) res;
    }
}

 
 
 
 
 
 
 
 
 
 
 
 
 
 

检索标记：382. 链表随机节点给你一个单链表，随机选择链表的一个节点，并返回相应的节点值。每个节点 被选中的概率一样 。实现 Solution 类：Solution(ListNode head) 使用整数数组初始化对象。int getRandom() 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相等。334. 递增的三元子序列给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。1220. 统计元音字母序列的数目给你一个整数 n，请你帮忙统计一下我们可以按下述规则形成多少个长度为 n 的字符串：字符串中每个字符都应当是小写元音字母（‘a’, ‘e’, ‘i’, ‘o’, ‘u’）每个元音 ‘a’ 后面都只能跟着 'e’每个元音 ‘e’ 后面只能跟着 ‘a’ 或者是 'i’每个元音 ‘i’ 后面 不能 再跟着另一个 'i’每个元音 ‘o’ 后面只能跟着 ‘i’ 或者是 'u’每个元音 ‘u’ 后面只能跟着 'a’由于答案可能会很大，所以请你返回 模 10^9 + 7 之后的结果。