现有6个矩阵（p[]={30,35,15,5,10,25,35}）进行连乘，试采用动态规划思想设计算法进行求解，输出该连乘矩阵的最小数乘次数和最优加括号方式。java实现

为了使用动态规划解决这个问题，我们可以创建一个二维数组dp，其中dp[i][j]表示从第一个元素到第i个元素，一共j个数相乘所需的最小乘法次数。我们还需要跟踪每个dp值对应的最优加括号表达式。这里是一个基本的Java实现思路：

public class MatrixMultiplicationDP {
    public static int[] p = {30, 35, 15, 5, 10, 25, 35}; // 输入矩阵

    public static String minOperationsAndParentheses(int n) {
        int[][] dp = new int[n + 1][n + 1];
        String[][] parentheses = new String[n + 1][n + 1];

        for (int i = 1; i <= n; i++) {
            dp[i][1] = 0;
            parentheses[i][1] = "";
        }

        for (int j = 2; j <= n; j++) {
            dp[1][j] = Integer.MAX_VALUE; // 初始化首行全为极大值
            parentheses[1][j] = "();"; // 首行所有情况都放括号
        }

        for (int i = 2; i <= n; i++) {
            for (int j = 2; j <= n; j++) {
                for (int k = 1; k < j; k++) {
                    int currentOps = dp[i - 1][k] + dp[k][j - 1]; // 两个子序列相乘
                    if (currentOps < dp[i][j]) {
                        dp[i][j] = currentOps;
                        parentheses[i][j] = parentheses[i - 1][k] + parentheses[k][j - 1];
                    }
                }
            }
        }

        return "Minimum operations: " + dp[n][n] +
               "\nOptimal parentheses: " + parentheses[n][n];
    }

    public static void main(String[] args) {
        int n = p.length;
        System.out.println(minOperationsAndParentheses(n));
    }
}

这个程序首先初始化dp数组和parentheses数组，然后遍历所有可能的子序列组合，并根据动态规划更新最少乘法次数和最优加括号表达式。最后，在main方法中调用minOperationsAndParentheses并打印结果。

注意，这个解决方案假设允许使用任意数量的括号，并且计算的是乘法操作次数而不是完整的表达式。实际应用中，可能需要进一步处理括号的顺序和平衡问题。