算法练习(6):牛客在线编程06 递归/回溯

java 复制代码
package jz.bm;

import java.io.PushbackInputStream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;

public class bm6 {
    /**
     * BM55 没有重复项数字的全排列
     */
    ArrayList<ArrayList<Integer>> res = new ArrayList<>();
    public ArrayList<ArrayList<Integer>> permute(int[] num) {
        if (num.length == 0) {
            return res;
        }
        Arrays.sort(num);
        boolean[] used = new boolean[num.length];
        Arrays.fill(used, false);
        dfs(num, used, new ArrayList<>());
        return res;
    }

    private void dfs(int[] num, boolean[] used, ArrayList<Integer> list) {
        if (list.size() == num.length) {
            res.add(new ArrayList<>(list));
        } else {
            for (int i = 0; i < num.length; i++) {
                if (used[i]) {
                    continue;
                }
                used[i] = true;
                list.add(num[i]);
                dfs(num, used, list);
                used[i] = false;
                list.remove(list.size() - 1);
            }
        }
    }


    /**
     * BM56 有重复项数字的全排列
     */
    public ArrayList<ArrayList<Integer>> permuteUnique(int[] num) {
        if (num.length == 0) {
            return res;
        }
        Arrays.sort(num);
        boolean[] used = new boolean[num.length];
        Arrays.fill(used, false);
        dfs56(num, used, new ArrayList<>());
        return res;
    }

    private void dfs56(int[] num, boolean[] used, ArrayList<Integer> list) {
        if (list.size() == num.length) {
            res.add(new ArrayList<>(list));
        } else {
            for (int i = 0; i < num.length; i++) {
                if (used[i]) {
                    continue;
                }
                if (i > 0 && num[i] == num[i - 1] && used[i - 1]) {
                    continue;
                }
                used[i]  = true;
                list.add(num[i]);
                dfs56(num, used, list);
                used[i] = false;
                list.remove(list.size() - 1);
            }
        }
    }
    /**
     * BM57 岛屿数量
     */
    public int solve (char[][] grid) {
        int m = grid.length;
        if (m == 0) {
            return 0;
        }
        int n = grid[0].length;
        if (n == 0) {
            return 0;
        }
        int res = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') {
                    res++;
                    dfs57(grid, m, n, i, j);
                }
            }
        }
        return res;
    }

    private void dfs57(char[][] grid, int m, int n, int i, int j) {
        grid[i][j] = '0';
        if (i - 1 >= 0 && grid[i - 1][j] == '1') {
            dfs57(grid, m, n, i - 1, j);
        }
        if (i + 1 < m && grid[i + 1][j] == '1') {
            dfs57(grid, m, n, i + 1, j);
        }
        if (j - 1 >= 0 && grid[i][j - 1] == '1') {
            dfs57(grid, m, n, i, j - 1);
        }
        if (j + 1 < n && grid[i][j + 1] == '1') {
            dfs57(grid, m, n, i, j + 1);
        }
    }
    /**
     * BM58 字符串的排列
     */
    ArrayList<String> strings = new ArrayList<>();
    public ArrayList<String> Permutation(String str) {
        if (str == null || "".equals(str)) {
            return strings;
        }
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        boolean[] used = new boolean[chars.length];
        Arrays.fill(used, false);
        dfs58(chars, used, new StringBuilder());
        return strings;
    }

    private void dfs58(char[] chars, boolean[] used, StringBuilder stringBuilder) {
        if (stringBuilder.length() == chars.length) {
            strings.add(new String(stringBuilder));
        } else {
            for (int i = 0; i < chars.length; i++) {
                if (used[i]) {
                    continue;
                }
                if (i > 0 && chars[i] == chars[i - 1] && used[i - 1]) {
                    continue;
                }
                stringBuilder.append(chars[i]);
                used[i] = true;
                dfs58(chars, used, stringBuilder);
                used[i] = false;
                stringBuilder.deleteCharAt(stringBuilder.length() - 1);
            }
        }
    }
    /**
     * BM60 括号生成
     */
    ArrayList<String> arrayList = new ArrayList<>();
    public ArrayList<String> generateParenthesis (int n) {
        if (n == 0) {
            return arrayList;
        }
        dfs60(n, 0, 0, new StringBuilder());
        return arrayList;
    }

    private void dfs60(int n, int left, int right, StringBuilder stringBuilder) {
        if (left == n && right == n) {
            arrayList.add(new String(stringBuilder));
            return;
        }
        if (left < n) {
            stringBuilder.append("(");
            dfs60(n, left + 1, right, stringBuilder);
            stringBuilder.deleteCharAt(left + right);
        }
        if (right < left && right < n) {
            stringBuilder.append(")");
            dfs60(n, left, right + 1, stringBuilder);
            stringBuilder.deleteCharAt(left + right);
        }
    }

    /**
     * BM61 矩阵最长递增路径
     */
    int max = 0;
    public int solve (int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        //这题dfs不需要记录visited, 因为能走的路径是单向的
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dfs61(matrix, m, n, i, j, 1);
            }
        }
        return max;
    }

    private void dfs61(int[][] matrix, int m, int n, int i, int j, int count) {
        if (i - 1 >= 0 && matrix[i - 1][j] > matrix[i][j]) {
            max = Math.max(count + 1, max);
            dfs61(matrix, m, n, i - 1, j, count + 1);
        }
        if (i + 1 < m &&  matrix[i + 1][j] > matrix[i][j]) {
            max = Math.max(count + 1, max);
            dfs61(matrix, m, n, i + 1, j, count + 1);
        }
        if (j - 1 >= 0 && matrix[i][j - 1] > matrix[i][j]) {
            max = Math.max(count + 1, max);
            dfs61(matrix, m, n, i, j - 1, count + 1);
        }
        if (j + 1 < n && matrix[i][j + 1] > matrix[i][j]) {
            max = Math.max(count + 1, max);
            dfs61(matrix, m, n, i, j + 1, count + 1);
        }
    }
}
相关推荐
一个天蝎座 白勺 程序猿10 分钟前
飞算JavaAI进阶:重塑Java开发范式的AI革命
java·开发语言·人工智能
前端 贾公子13 分钟前
tailwindCSS === 使用插件自动类名排序
java·开发语言
10岁的博客14 分钟前
代码编程:一场思维与创造力的革命
开发语言·算法
没有bug.的程序员19 分钟前
JAVA面试宝典 -《Spring Boot 自动配置魔法解密》
java·spring boot·面试
Aczone2839 分钟前
嵌入式 数据结构学习 (六) 树、哈希表与内核链表
数据结构·学习·算法
定偶40 分钟前
进制转换小题
c语言·开发语言·数据结构·算法
hnlucky1 小时前
《Nginx + 双Tomcat实战:域名解析、静态服务与反向代理、负载均衡全指南》
java·linux·服务器·前端·nginx·tomcat·web
hnlucky1 小时前
同时部署两个不同版本的tomcat要如何配置环境变量
java·服务器·http·tomcat·web
体系结构论文研讨会1 小时前
多项式环及Rq的含义
算法
智驱力人工智能2 小时前
极端高温下的智慧出行:危险检测与救援
人工智能·算法·安全·行为识别·智能巡航·高温预警·高温监测