算法导论第四章:函数的增长-全部代码实现

public class Main {
    public static void main(String[] args) {
        Main example = new Main();
        //最大子数组问题
//        int a=example.FIND_MAXIMUM_SUB_ARRAY(new int[]{13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7},0,15,Integer.MIN_VALUE);
//        int a=example.FIND_MAXIMUM_SUB_ARRAY(new int[]{13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7});
        int a=example.FIND_MAXIMUM_SUB_ARRAY_DYNAMIC_PROGRAMMING(new int[]{13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7});
        System.out.println("起始点:"+(max_left+1)+" 终点:"+(max_right+1)+" 和为:"+a);

        //矩阵乘法(Strassen算法略)
        int C[][] = example.SQUARE_MATRIX_MULTIPLY(new int[][]{{1, 4, 2}, {3, 4, 1}, {2, 4, 5}}, new int[][]{{2, 4, 1}, {1, 5, 2}, {1, 5, 6}});
        for (int[] i : C) { for (int j : i) { System.out.print(j+" "); }System.out.println(); }
    }


    //记录起始点和终点
    static int max_left;
    static int max_right;
    //分治法
    public int FIND_MAXIMUM_SUB_ARRAY(int[]A,int low,int high,int curr){
        if (high-low==1) return curr;
        else {
            int mid=low+(high-low)/2;
            //把分治得出的值直接赋值给合并所用的值
            int left = FIND_MAXIMUM_SUB_ARRAY(A, low, mid, curr);
            int right = FIND_MAXIMUM_SUB_ARRAY(A, mid, high, curr);
            int cross = FIND_MAXIMUM_SUB_ARRAY(A, low, mid, high);
            if(left>right&&right>cross){
                max_left=low;
                max_right=mid;
                return left;
            }
            if(right>left&&right>cross){
                max_left=mid;
                max_right=right;
                return left;
            }else return cross;
        }
    }
    public int FIND_MAX_CROSSING_SUB_ARRAY(int[]A,int low,int mid,int high){
        int[] cross=new int[3];
        int left_sum = Integer.MIN_VALUE;
        int sum=0;
        //从mid向两边求和
        for (int i=mid;i>=low;i--){
            sum=sum+A[i];
            if (sum>left_sum){
                left_sum=sum;
                max_left=i;
            }
        }
        int right_sum=Integer.MIN_VALUE;
        sum = 0;
        for (int i = mid + 1; i <= high; i++) {
            sum=sum+A[i];
            if (sum > right_sum) {
                right_sum=sum;
                max_right=i;
            }
        }
        return left_sum+right_sum;
    }

    //暴力求解法
    public int FIND_MAXIMUM_SUB_ARRAY(int[]A){
        int sum = A[0];
        int curr = sum;
        for(int i=0;i<A.length;i++){
            curr=A[i];
            for (int j=i+1;j<A.length;j++){
                curr=curr+A[j];
                if (curr > sum) {
                    sum=curr;
                    max_left=i;
                    max_right=j;
                }
            }
        }
        return sum;
    }
    //动态规划
    public int FIND_MAXIMUM_SUB_ARRAY_DYNAMIC_PROGRAMMING(int[] A) {
        int max=A[0];
        int dp[][]=new int[A.length+1][A.length];
        for (int i=0;i<A.length;i++)dp[1][i]=A[i];
        for (int i=2;i<A.length+1;i++){
            for (int j=0;j<A.length-i+1;j++){
                dp[i][j]=dp[i-1][j]+A[i+j-1];
                if (dp[i][j]>max){
                    max_left=j;
                    max_right=j+i-1;
                    max=dp[i][j];
                }
            }
        }
        return max;
    }
    
    
    public int[][]SQUARE_MATRIX_MULTIPLY(int[][]A,int[][]B){
        int n=A.length;
        int C[][] = new int[A.length][A[0].length];
        for (int i=0;i<n;i++){
            for (int j = 0; j < n; j++) {
                int curr=0;
                for (int k = 0; k < n; k++) {
                    curr=curr+A[i][k]*B[k][j];
                }
                C[i][j]=curr;
            }
        }
        return C;
    }
}