int **p;int *p的表达是否正确

int **p; int *p的表达是正确的。

在C语言中，int **p表示一个指向指针的指针，而int *p表示一个指向整型变量的指针。这两种表达方式都是合法的，但它们的含义是不同的。

int **p表示p是一个指向指针的指针，也就是说p存储的是一个指针的地址。而int *p表示p是一个指向整型变量的指针，也就是说p存储的是一个整型变量的地址。

下面是一个示例代码，演示了int **pint *p的用法：

#include <stdio.h>

int main() {
    int a = 10;
    int *p = &a;
    int **q = &p;

    printf("a = %\n", a); // 输出：a = 10
    printf("*p = %d\n", *p); // 输出：*p = 10
    printf("**q = %d\n", **q); // 输出：**q = 10

    return 0;
}

在这个示例中，我们定义了一个整型变量a，并将其地址赋给指针p。然后，我们定义了一个指向指针的指针q，并将指针p的地址赋给q。通过*q和**q，我们可以访问到变量a的值。

相关问题

设有一个字符串A$的结构为:A$= m<n>p 其中m为数字串(长度<=20),而n,p均为1或2位的数字串(其中所表达的内容在2-10之间)。 程序要求: 从键盘上读入A$后(不用正确性检查),将A$中的数字串m(n进制),以p

进制输出。

首先，我们需要提取出A$中的数字串m、n、p。可以使用正则表达式进行匹配。

以下是Python实现代码：

import re

a = input("请输入A$: ")
pattern = r'(\d+)<(\d{1,2})>(\d{1,2})'
match = re.search(pattern, a)

if match:
    m = match.group(1)
    n = int(match.group(2))
    p = int(match.group(3))
    decimal_m = int(m, n)
    print(f"{m}({n}) = {decimal_m}({10})")
    result = ''
    while decimal_m > 0:
        result = str(decimal_m % p) + result
        decimal_m //= p
    print(f"{m}({n}) = {result}({p})")
else:
    print("输入格式不正确！")

代码说明：

1. 使用`input()`函数从键盘上读入A$；
2. 使用正则表达式`r'(\d+)<(\d{1,2})>(\d{1,2})'`匹配A$中的数字串m、n、p；
3. 使用`re.search()`函数在A$中搜索匹配项；
4. 如果匹配成功，使用`match.group()`方法提取出m、n、p；
5. 使用`int()`函数将m从n进制转换为十进制；
6. 输出m的十进制表示；
7. 将十进制的m转换为p进制并输出。

示例输入：

请输入A$: 101<2>8

示例输出：

101(2) = 5(10)
101(2) = 1010(8)

应用动态规划算法的最优子结构性质和子问题重叠性质求解此问题。分析动态规划算法的基本思想，应用动态规划策略写出算法及相应的程序，求解此题。要读懂读透A[i,j]，A[1,n]=A[1,k] ×A[k+1,n]，m[i][j]，s[i][j]各式所表达的含义并正确加以应用。m[i][j]的递归定义：C语言

动态规划算法的基本思想是将原问题分解成若干个子问题，先求解子问题，然后利用子问题的解构造出原问题的解。

对于矩阵连乘问题，我们可以定义一个二维数组A来表示矩阵连乘的最小代价，其中A[i,j]表示从第i个矩阵到第j个矩阵的最小代价。同时，我们可以定义两个二维数组m和s，其中m[i,j]表示从第i个矩阵到第j个矩阵的最小代价，s[i,j]表示从第i个矩阵到第j个矩阵的最小代价的断点。

根据题目中的最优子结构性质和子问题重叠性质，我们可以得到矩阵连乘问题的动态规划转移方程：

A[i,j] = min{A[i,k] + A[k+1,j] + p[i-1]*p[k]*p[j]}，其中i ≤ k < j

m[i,j] = A[i,j]，当i=j时，m[i,j]=0

s[i,j] = k，其中i ≤ k < j，且A[i,j]=A[i,k]+A[k+1,j]+p[i-1]*p[k]*p[j]

接下来，我们可以根据上述转移方程编写求解矩阵连乘问题的动态规划算法程序：

#include <stdio.h>
#include <stdlib.h>

#define MAX_N 100

void matrixChainOrder(int* p, int n, int m[MAX_N][MAX_N], int s[MAX_N][MAX_N]) {
    for (int i = 1; i <= n; i++) {
        m[i][i] = 0;
    }
    for (int l = 2; l <= n; l++) {
        for (int i = 1; i <= n-l+1; i++) {
            int j = i+l-1;
            m[i][j] = INT_MAX;
            for (int k = i; k < j; k++) {
                int q = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
                if (q < m[i][j]) {
                    m[i][j] = q;
                    s[i][j] = k;
                }
            }
        }
    }
}

void printOptimalParens(int s[MAX_N][MAX_N], int i, int j) {
    if (i == j) {
        printf("A%d", i);
    } else {
        printf("(");
        printOptimalParens(s, i, s[i][j]);
        printOptimalParens(s, s[i][j]+1, j);
        printf(")");
    }
}

int main() {
    int p[MAX_N];
    int n;
    printf("请输入矩阵个数：");
    scanf("%d", &n);
    printf("请输入%d个矩阵的行列数（如A1为2x3，则输入2 3）：\n", n);
    for (int i = 0; i <= n; i++) {
        int row, col;
        scanf("%d %d", &row, &col);
        p[i] = row;
    }
    p[n] = col;
    int m[MAX_N][MAX_N];
    int s[MAX_N][MAX_N];
    matrixChainOrder(p, n, m, s);
    printf("最小代价为：%d\n", m[1][n]);
    printf("最优加括号方案为：");
    printOptimalParens(s, 1, n);
    printf("\n");
    return 0;
}

在程序中，我们使用了两个函数matrixChainOrder和printOptimalParens。其中，matrixChainOrder函数用于求解矩阵连乘的最小代价，并计算出每次计算的断点；printOptimalParens函数用于输出最优加括号方案。

需要注意的是，在编写程序时，需要将矩阵的行列数作为输入，因此我们在输入矩阵行列数时，需要输入n+1个数，其中第i个数表示第i个矩阵的行数，第i+1个数表示第i个矩阵的列数。同时，我们还需要在程序中包含头文件<stdlib.h>和<limits.h>，以使用INT_MAX宏定义。