矩阵处理/贪心算法/并查集/图

武田

已于 2022-07-28 20:43:10 修改

阅读量283

点赞数 1

文章标签：大数据算法数据结构 leetcode

于 2022-07-07 16:43:24 首次发布

本文链接：https://blog.csdn.net/weixin_44786370/article/details/125662315

版权

金条切分问题，每次切分都需要花费和长度一样的铜板，返回分割的最小代价

项目花费、项目利润、串行做的项目数、初始资金

矩阵处理技巧

1）zigzag打印矩阵

2）转圈打印矩阵

3）原地旋转正方形矩阵

核心技巧：找到coding上的宏观调度

看coding更易理解，图是辅助作用。

zigzag打印矩阵

public class Code04_ZigZagPrintMatrix {

    public static void printMatrixZigZag(int[][] matrix) {
        int tR = 0; // a 行
        int tC = 0; // a 列
        int dR = 0; // b 行
        int dC = 0; // b 列
        int endR = matrix.length - 1;     // 终止位置行
        int endC = matrix[0].length - 1;  // 终止位置列
        boolean fromUp = false;   // 是不是从右上往左下打印
        while (tR != endR + 1) {
            printLevel(matrix, tR, tC, dR, dC, fromUp);
            tR = tC == endC ? tR + 1 : tR;
            tC = tC == endC ? tC : tC + 1;
            //先动的东西写再最后，要不会出错。 边界问题
            dC = dR == endR ? dC + 1 : dC;
            dR = dR == endR ? dR : dR + 1;
            fromUp = !fromUp;
        }
        System.out.println();
    }

    public static void printLevel(int[][] m, int tR, int tC, int dR, int dC, boolean f) {
        if (f) {
            while (tR != dR + 1) {
                System.out.print(m[tR++][tC--] + " ");
            }
        } else {
            while (dR != tR - 1) {
                System.out.print(m[dR--][dC++] + " ");
            }
        }
    }

    public static void main(String[] args) {
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };
        printMatrixZigZag(matrix);
    }
}

转圈打印矩阵

public class Code05_PrintMatrixSpiralOrder {

    public static void spiralOrderPrint(int[][] matrix) {
        int tR = 0;   // a
        int tC = 0;   // a
        int dR = matrix.length - 1;   // b
        int dC = matrix[0].length - 1;  // b
        while (tR <= dR && tC <= dC) {
            printEdge(matrix, tR++, tC++, dR--, dC--);
        }
    }

    public static void printEdge(int[][] m, int tR, int tC, int dR, int dC) {
        if (tR == dR) {    //行相同时
            for (int i = tC; i <= dC; i++) {
                System.out.print(m[tR][i] + " ");
            }
        } else if (tC == dC) {
            for (int i = tR; i <= dR; i++) {
                System.out.print(m[i][tC] + " ");
            }
        } else {
            int curC = tC;
            int curR = tR;
            while (curC != dC) {
                System.out.print(m[tR][curC] + " ");
                curC++;
            }
            while (curR != dR) {
                System.out.print(m[curR][dC] + " ");
                curR++;
            }
            while (curC != tC) {
                System.out.print(m[dR][curC] + " ");
                curC--;
            }
            while (curR != tR) {
                System.out.print(m[curR][tC] + " ");
                curR--;
            }
        }
    }

    public static void main(String[] args) {
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 },
                { 13, 14, 15, 16 } };
        spiralOrderPrint(matrix);

    }
}

原地旋转正方形矩阵

public class Code06_RotateMatrix {

    public static void rotate(int[][] matrix) {
        int a = 0;
        int b = 0;
        int c = matrix.length - 1;
        int d = matrix[0].length - 1;
        while (a < c) {
            rotateEdge(matrix, a++, b++, c--, d--);
        }
    }

    public static void rotateEdge(int[][] m, int a, int b, int c, int d) {
        int tmp = 0;
        for (int i = 0; i < d - b; i++) {
            tmp = m[a][b + i];
            m[a][b + i] = m[c - i][b];
            m[c - i][b] = m[c][d - i];
            m[c][d - i] = m[a + i][d];
            m[a + i][d] = tmp;
        }
    }
    // for test
    public static void printMatrix(int[][] matrix) {
        for (int i = 0; i != matrix.length; i++) {
            for (int j = 0; j != matrix[0].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 } };
        printMatrix(matrix);
        rotate(matrix);
        System.out.println("=========");
        printMatrix(matrix);

    }

}

贪心算法

对于贪心算法的学习主要以增加阅历和经验为主

堆和排序，是贪心中最常用的俩个手段

贪心算法求解的标准过程

1）分析业务

2）根据业务逻辑找到不同的贪心策略

3）对于能举出反例的策略直接跳过，不能举出反例的策略要证明有效性

这往往是特别困难的，要求数学能力很高且不具有统一的技巧性

贪心算法的解题思路

1）实现一个不依赖贪心策略的解法X，可以用最暴力的尝试

2）脑补出贪心策略A、贪心策略B、贪心策略C....

3）用解法X和对数器，用实验的方式得知哪个贪心策略正确

4）不要去纠结贪心策略的证明

会议室宣讲，返回最多的宣讲场次

分析可知，谁结束时间早，先安排~~~可以得到最优解

    public static class Program {
        public int start;
        public int end;

        public Program(int start, int end) {
            this.start = start;
            this.end = end;
        }
    }

    // 暴力！所有情况都尝试！
    public static int bestArrange1(Program[] programs) {
        if (programs == null || programs.length == 0) {
            return 0;
        }
        return process(programs, 0, 0);
    }

    // 还剩下的会议都放在programs里
    // done之前已经安排了多少会议的数量
    // timeLine目前来到的时间点是什么

    // 目前来到timeLine的时间点，已经安排了done多的会议，剩下的会议programs可以自由安排
    // 返回能安排的最多会议数量
    public static int process(Program[] programs, int done, int timeLine) {
        if (programs.length == 0) {
            return done;
        }
        // 还剩下会议
        int max = done;
        // 当前安排的会议是什么会，每一个都枚举
        for (int i = 0; i < programs.length; i++) {
            if (programs[i].start >= timeLine) {
                Program[] next = copyButExcept(programs, i);
                max = Math.max(max, process(next, done + 1, programs[i].end));
            }
        }
        return max;
    }
    //从programs中移除i
    public static Program[] copyButExcept(Program[] programs, int i) {
        Program[] ans = new Program[programs.length - 1];
        int index = 0;
        for (int k = 0; k < programs.length; k++) {
            if (k != i) {
                ans[index++] = programs[k];
            }
        }
        return ans;
    }
    // 贪心算法
    // 会议的开始时间和结束时间，都是数值，不会 < 0
    public static int bestArrange2(Program[] programs) {
        Arrays.sort(programs, new ProgramComparator());
        int timeLine = 0;
        int result = 0;
        // 依次遍历每一个会议，结束时间早的会议先遍历
        for (int i = 0; i < programs.length; i++) {
            if (timeLine <= programs[i].start) {
                result++;
                timeLine = programs[i].end;
            }
        }
        return result;
    }

    public static class ProgramComparator implements Comparator<Program> {

        @Override
        public int compare(Program o1, Program o2) {
            return o1.end - o2.end;
        }

    }

返回至少点亮几盏灯

最低0.47元/天解锁文章

武田

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
矩阵处理/贪心算法/并查集/图

算法与数据结构(基础篇3)
复制链接

扫一扫

矩阵处理/贪心算法/并查集/图

矩阵处理技巧

zigzag打印矩阵

转圈打印矩阵

原地旋转正方形矩阵

贪心算法

贪心算法求解的标准过程

贪心算法的解题思路

会议室宣讲，返回最多的宣讲场次

返回至少点亮几盏灯

“相关推荐”对你有帮助么？