算法——分治算法专练（1）

Code Slacker

于 2023-06-21 17:05:38 发布

阅读量487

点赞数 1

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

本文链接：https://blog.csdn.net/qq_73044452/article/details/130894015

版权

文章介绍了使用分治策略解决二维极大点问题的算法，通过递归地将点集划分为两半并比较极值来找到平面中的极大点。同时，文章展示了Strassen算法在矩阵乘法中的实现，通过将大矩阵分解为小矩阵并递归计算，以期望达到更快的运算速度。尽管Strassen算法在某些情况下效率并不优于朴素矩阵乘法，但它在理论上的优化意义仍然显著。

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

1、求二维极大点问题

在平面中找出极大点的分治算法
输入：n个平面点的集合S。
输出：S的极大点。
步骤1. 如果S只含一个点，那么输出该点为极大点；否则，找一条垂直于x轴的直线L，它划分点集合为两个子集合SL和SR，每个子集含有n/2个点。
步骤2. 递归地找出SL和SR的极大点。
步骤3. 将SL和SR的极大点投影到Y轴上，如果SL中的极大点的y值小于SR中某个极大点的y值，那么舍弃它。

import java.util.ArrayList;
public class MaximumPoint {
    public static Point maximum(ArrayList<Point> S) {
        if (S.size() == 1) {
            return S.get(0);
        }
        ArrayList<Point> SL = new ArrayList<>();
        ArrayList<Point> SR = new ArrayList<>();
        int midIndex = S.size() / 2;
        double midX = S.get(midIndex).getX();
        for (int i = 0; i < S.size(); i++) {
            Point p = S.get(i);
            if (p.getX() < midX) {
                SL.add(p);
            } else {
                SR.add(p);
            }
        }
      /* // for (Point p : S) {
           if (p.getX() < midX) {
            SL.add(p);
          } else {
           SR.add(p);
         }
        }*/

        Point maxL = maximum(SL);
        Point maxR = maximum(SR);
        if (maxL.getY() >= maxR.getY()) {
            return maxL;
        } else {
            return maxR;
        }
    }

    public static void main(String[] args) {
        ArrayList<Point> S = new ArrayList<>();
        Point p1 = new Point(1, 5);
        Point p2 = new Point(3, 8);
        Point p3 = new Point(6, 3);
        Point p4 = new Point(8, 4);
        Point p5 = new Point(10, 9);
        S.add(p1);
        S.add(p2);
        S.add(p3);
        S.add(p4);
        S.add(p5);


        Point maxPoint = maximum(S);
        System.out.println("最大值点坐标为：" + maxPoint.getX() + ", " + maxPoint.getY());
    }
}

class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }
}

在该代码中，我们定义了一个MaximumPoint类，其中包含一个静态方法maximum，用于在递归过程中找出集合S的极大点。此外，还定义了一个Point类，用于表示平面中的一个点。

在maximum方法中，如果该集合只含有一个点，则返回该点；否则，我们找一条垂直于x轴的直线L，将点集S分为两个子集SL和SR，并递归调用maximum方法以找出SL和SR的极大点。最后，将SL和SR的极大点投影到Y轴上，比较它们的y值，并返回具有更大y值的极大点。在主函数中，我们可以创建一个点集，并调用maximum方法，以查找该点集的极大点。

时间复杂度O（nlogn）

2、特斯拉森矩阵

public class StrassenAlgorithm {
    public static int[][] strassen(int[][] matrix1, int[][] matrix2) {
        int n = matrix1.length;

        // base case
        if (n == 1) {
            int[][] result = new int[1][1];
            result[0][0] = matrix1[0][0] * matrix2[0][0];
            return result;
        }

        // divide matrix into submatrices
        int[][] a11 = new int[n/2][n/2];
        int[][] a12 = new int[n/2][n/2];
        int[][] a21 = new int[n/2][n/2];
        int[][] a22 = new int[n/2][n/2];

        int[][] b11 = new int[n/2][n/2];
        int[][] b12 = new int[n/2][n/2];
        int[][] b21 = new int[n/2][n/2];
        int[][] b22 = new int[n/2][n/2];

        for (int i = 0; i < n/2; i++) {
            for (int j = 0; j < n/2; j++) {
                a11[i][j] = matrix1[i][j];
                a12[i][j] = matrix1[i][j + n/2];
                a21[i][j] = matrix1[i + n/2][j];
                a22[i][j] = matrix1[i + n/2][j + n/2];

                b11[i][j] = matrix2[i][j];
                b12[i][j] = matrix2[i][j + n/2];
                b21[i][j] = matrix2[i + n/2][j];
                b22[i][j] = matrix2[i + n/2][j + n/2];
            }
        }

        // recursive calls to compute the seven products
        int[][] p1 = strassen(a11, subtract_matrices(b12, b22));
        int[][] p2 = strassen(add_matrices(a11, a12), b22);
        int[][] p3 = strassen(add_matrices(a21, a22), b11);
        int[][] p4 = strassen(a22, subtract_matrices(b21, b11));
        int[][] p5 = strassen(add_matrices(a11, a22), add_matrices(b11, b22));
        int[][] p6 = strassen(subtract_matrices(a12, a22), add_matrices(b21, b22));
        int[][] p7 = strassen(subtract_matrices(a11, a21), add_matrices(b11, b12));

        // compute the submatrices of C using the seven products
        int[][] c11 = add_matrices(subtract_matrices(add_matrices(p5, p4), p2), p6);
        int[][] c12 = add_matrices(p1, p2);
        int[][] c21 = add_matrices(p3, p4);
        int[][] c22 = subtract_matrices(subtract_matrices(add_matrices(p5, p1), p3), p7);

        // combine the submatrices into matrix C
        int[][] result = new int[n][n];
        for (int i = 0; i < n/2; i++) {
            for (int j = 0; j < n/2; j++) {
                result[i][j] = c11[i][j];
                result[i][j + n/2] = c12[i][j];
                result[i + n/2][j] = c21[i][j];
                result[i + n/2][j + n/2] = c22[i][j];
            }
        }
        return result;
    }

    public static int[][] add_matrices(int[][] matrix1, int[][] matrix2) {
        int n = matrix1.length;
        int[][] result = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                result[i][j] = matrix1[i][j] + matrix2[i][j];
            }
        }
        return result;
    }

    public static int[][] subtract_matrices(int[][] matrix1, int[][] matrix2) {
        int n = matrix1.length;
        int[][] result = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                result[i][j] = matrix1[i][j] - matrix2[i][j];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] matrix1 = {{1, 2}, {3, 4}};
        int[][] matrix2 = {{5, 6}, {7, 8}};

        int[][] result = strassen(matrix1, matrix2);

        System.out.println("Result:");
        for (int[] row : result) {
            System.out.println(Arrays.toString(row));
        }
    }
}

在该实现中，我们定义了三个静态方法：