leetcode-213场周赛

1640. 能否连接形成数组

题目-1640. 能否连接形成数组

遍历arr中的每一个元素，如果与pieces中的第一个元素相等，则依次遍历pieces中的元素。

class Solution {
    public boolean canFormArray(int[] arr, int[][] pieces) {
        boolean flag = true;
        boolean flag2 = true;
        
        int cnt = 0;
        for (int i = 0; i < pieces.length; i++){
            cnt += pieces[i].length;
        }
        // arr 和 pieces 中元素长度不等，直接退出
        if (cnt != arr.length) return false;
        
        int i = 0;
        for (i = 0; i < arr.length; ){ 
             // 如果在pieces中找不到，直接退出  
            if (!flag2) return false;
            flag2 = false;
            for (int j = 0; j < pieces.length; j++){
                 // 与pieces中元素相同
                if (arr[i] == pieces[j][0]){
                    flag2 = true;
                    for (int k = 0; k < pieces[j].length; k++){
                        
                        if (arr[i] == pieces[j][k]){
                            i++;
                        }
                        else{
                            
                            return false;
                        }
                    }
                    break;
                }
            }
        }
        return flag;
    }
}

1641. 统计字典序元音字符串的数目

题目-1641. 统计字典序元音字符串的数目

直接dfs暴力次数

class Solution {
    int cnt = 0;
    public void dfs(int i, int cur, int n){
        if (cur == n - 1){
            cnt += 1;
            return ;
        }
        for (int j = i ; j < 5; j++){
            dfs(j, cur + 1, n);
        }
    }
    
    public int countVowelStrings(int n) {
        for (int i = 0; i < 5; i++){
            dfs(i, 0, n);
        }
        return cnt;
    }
}

1642. 可以到达的最远建筑

题目-1642. 可以到达的最远建筑

贪心—先用所有的梯子，当梯子用完后，在所有梯子中寻找用砖最少的，然后用砖替换掉。

class Solution {
    public int furthestBuilding(int[] heights, int bricks, int ladders) {
        int n = heights.length, sum = 0;
        Queue<Integer> queue = new PriorityQueue<>();
        for(int i = 1; i < heights.length; i++) {
            int diff = heights[i] - heights[i - 1];
            // 梯子用完
            if(diff > 0) {
                queue.offer(diff);
                if(queue.size() > ladders) {
                    sum += queue.poll();
                }
                if(sum > bricks)
                    return i - 1;
            }
        }
        return n - 1;
    }
}

1643. 第 K 条最小指令

题目-1643. 第 K 条最小指令

第一想法暴力生成下一个序列，那么多序列。。。
这题是路径计算的一个简单变种，对于dp[i][j] 我们可以来源于dp[i-1][j]和dp[i][j-1]。由于第k个序列，我们则会优先选择走H，即从dp[i-1][j]到达dp[i][j]，当k>dp[i-1][j]时，说明所走的H方案数并不够，只能来源于V。

class Solution {
    public String kthSmallestPath(int[] destination, int k) {
        int n = destination[1];
        int m = destination[0];
        int[][] dp = new int[n + 1][m + 1];

        for (int i = 0; i <= n; i++){
            dp[i][0] = 1;
        }
        for (int i = 0; i <= m; i++){
            dp[0][i] = 1;
        }
        // dp 求解路径数
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= m; j++){
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }

        int i = n, j = m;
        StringBuilder sb = new StringBuilder();
        while (i >= 1 && j >= 1){
            // 当前所需的路径数超过来源于上方，则只能走左边
            if (k > dp[i - 1][j]){
                sb.append("V");
                k -= dp[i - 1][j];
                j--;
            }
            else{
                sb.append("H");
                i--;
            }
        }
        // 补充边界条件
        while (i >= 1){
            sb.append("H");
            i--;
        }
        while (j >= 1){
            sb.append("V");
            j--;
        }
        return sb.toString();
    }
}