从刚开始接触背包到现在，已经快两个月了，学完背包之后就又继续学其它东西，现在该回头再来复习一下，整理整理自己的思路，使自己对背包更熟练一点，这里自己先复习一下0/1背包和完全背包。
　　0/1背包的主要思路就是:这件物品，取还是不取。用一个二维数组dp[i][v]来表示对第i个物品，背包容量为v时的情况。c[i]表示第i件物品的体积，w[i]表示第i件物品的价值。那么考虑第i件物品取与不取:如果不取，那么就可以转化为i-1件物品、容量仍然为v、价值没有增加的情况(dp[i-1][v])；如果取，那么转化为i-1件物品、容量减去第i件物品的体积后剩余容量、价值加上第i件物品的价值后的情况(dp[i-1][ v-c[i] ] + w[i] )。为了让背包中物品价值最大，我们取二者较大者，也就是
dp[i][v]=max{ dp[i-1][v] , dp[i-1][ v-c[i] ] + w[i] }。好了，现在思考如何将数组压缩，对于这两种情况下dp[i][v]值的改变，要么是dp[i][v]=dp[i-1][v],要么是dp[i][v]=dp[i-1][ v-c[i] ] + w[i]。假设下面是就是二维数组dp的一部分,
　　　　　　a　　　　b　　　　dp[i-1][v]　　　　d　　　　e
　　　　　　f　　　　g　　　 　dp[i][v] &　　　　&h & & & & &k
　　我们可以发现：如果dp[i][v]=dp[i-1][v],那么相当于直接复制dp[i][v]上面的元素dp[i-1][v]值。而如果dp[i][v]=dp[i-1][ v-c[i] ] + w[i]，注意到，v-c[i]&=v，所以，dp[i][v]的值是由上面红色的元素加上w[i]得到，也就是说，我们每次想要更新dp[i][v],可能会用到的值只有上面红色的部分，所以，我们就能把二维数组压缩为一维数组，只需要每次从后往前更新dp[i][v]的值。这样就用dp[v]来表示容量为v的情况下，背包内物品的价值，状态转移方程也就成了：
　　dp[v]=max{ dp[v] , dp[ v-c[i] ] + w[i] }
　　对于完全背包，一件物品可以取多次，我们仍然使用0/1背包的思想:这件物品，取还是不取。唯一的变化是，取了这件物品，还可以取。所以，如果取，仍然是i件物品的问题( dp[i][ v - c[i]] + w[i]);如果不取，dp[i][v]还是dp[i-1][v]都一样(第一次不取，以后也不会取，相当于转化成i-1件物品的问题，为了和取的情况保持一致，采用dp[i][v])。所以状态转移方程变为了dp[i][v]=max{ dp[i][v] , dp[i][ v-c[i] ] + w[i] },那么在数组里，
　　　　　　a　　　　b　　　　m　　　　　　　　d　　　　e
　　　　　　f　　　　g　　　 　dp[i][v]&&　　　　&h & & & & &k
　　同样注意到，v-c[i]&=v,所以，每次更新dp[i][v],可能用到的值是红色部分，所以也可以压缩为一维，这里要注意了，数组中的f、g，是i下的情况，并不是i-1的情况，dp[i][v]的值取决取i下，而不是i-1,所以此时应该从前往后更新dp的值，这样才能保证取第i件物品时，dp[i][v]是由dp[i][v-c[i]]+w[i]推得，所以尽管状态转移方程仍然为dp[v]=max{ dp[v] , dp[ v-c[i] ] + w[i] }，v的循环顺序却应该是从小到大。
　　基本上，这就是0/1背包和完全背包从二维转化为一维的思路，以后自己还要经常复习。
　　0/1背包的伪代码：
for i=1 to N
for v=V to 0
f[v]=max{dp[v],dp[v-c[i]]+w[i]}
　　完全背包的伪代码：
for i=1 to N
for v=0 to V
f[v]=max{dp[v],dp[v-c[i]]+w[i]}
阅读(...) 评论()6.C语言第四章数组(1)_中华文本库
第1页/共5页
文本预览：
本次课主要内容
第4章 数组
4.1 一维数组 4.1.1 一维数组的定义 4.1.2 一维数组的引用 4.1.3 一维数组的初始化 4.2 二维数组 4.1.4 一维数组程序举例 4.2.1 二维数组的定义 4.2.2 二维数组的引用 4.2.3 二维数组的初始化 4.2.4 二维数组程序举例
第4章 数组
4.1 一维数组
4.1.1 一维数组的定义
定义一维数组的一般形式为： 类型说明符 数组名[常量表达式]； 数组名：取名规则和变量名相同，遵循标识 符命名规则； 常量表达式：其值指定了该数组中数组元素 的个数，即数组长度； 类型说明符：指定该数组所有元素的数据类 型。例如：int a[5];
注意： （1）数组名不能与其他变量名重名。数组 名后是用方括号括起来的常量表达式，不 能用圆括号。 （2） C语言的数组元素下标从0开始。则数 组a的5个元素为a[0],a[1],a[2],a[3],a[4]， 而不包含a[5]。在C语言中，不对数组作边 界检查，如果程序中出现了下标越界，可 能会造成程序运行结果的错误。因此要注 意下标不能过界。 （3）C语言不允许对数组的长度作动态定 义，即数组长度不能是变量。
4.1.1 一维数组的定义
4.1.1 一维数组的定义
例如： #include void main( ) {int n=5； int a[n]； … ｝ 是错误的。 （4）可以一次同时定义多个同类型数组。 例如：int a[5]，b[l0]；
4.1.2 一维数组的引用
数组元素的一般表示形式为： 数组名[下标] 下标通常为整型常量或整型表达式，若为小数， 系统自动取整。例如：a[5]，a[i+j]，a[2*2]等都 是合法的数组元素。 数组必须先定义，后使用。使用数值型数组时， 要逐个引用数组元素而不能一次引用整个数组。 例如： for(i=0; i<5; i++) printf ("%d" a[i])； 下面的写法是错误的： printf("%d" a)；
4.1.2 一维数组的引用
【例4-1】从键盘输入10个整数，找出其中的最大数 并输出。 #include
void main( ) {int a[10],i, for(i=0; i<10; i++) scanf("%d" &a[i]); max=a[0]; for(i=1; i<10; i++) 输出结果： if(max< a[i]) max=a[i]; MAX= 90 printf("MAX=%d" max); } 输入数据: 12，25，77，68，9，45，4，36，90，17 ↙
4.1.3 一维数组初始化
在定义数组的同时对数组元素赋以初值，即为 数组的初始化。初始化是在编译时进行的， 故不占用运行时间。 （1）对数组的全部元素进行赋初值。 例如： int a[5]={1，3，5，7，9}； 即在定义数组时用一对花括号将要赋给数组各 元素的值括起来，各值之间用逗号间隔，按 其顺序赋给该数组。经定义和初始化后， a[0]=1,a[1]=3,a[2]=5,a[3]=7,a[4]=9。
4.1.3 一维数组初始化
整型数组a[5]的5个元素全都为l，初始化时应 写成： int a[5]={1,1,1,1,1}； 不能写成：int a[5]=1； （2）对数组的全部元素赋初值时，也可以不 指
第1页/共5页
寻找更多 ""C语言的二维数组和一维数组：为什么上面是arr[2][4];下面是arr[0],arr[1]，呢，不是应该写二维的格式吗？_百度知道
提问者采纳
这种用法是把arr[看做了一个字符串数组，共有arr[0]、arr[1]两个元素，每个元素字符串的长度是4个字节，包括串结束符若满意请及时采纳，谢谢
那下面的arr【0】【3】呢
这是把arr[0]字符串中的第四个字符修改为&字符
提问者评价
其他类似问题
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁设两个栈(stack1,stack2)共享一个一维数组空间s[m],它们的栈底分别设在数组的两端,试编写一个算法,_百度知道
设两个栈(stack1,stack2)共享一个一维数组空间s[m],它们的栈底分别设在数组的两端,试编写一个算法,
设两个栈(stack1,stack2)共享一个一维数组空间s[m],它们的栈底分别设在数组的两端,试编写一个算法,从键盘输入一个整数x,该数大于100时放入stack2,否则放入stack1.？
typedef struct{int data[100];int top1;int top2;}Svoid Push(Stack *s, int e, int StackNumber)在这里设置一个参数StackNumber用来判断是栈1还是栈2就行了，其他的插入类似
其他类似问题
按默认排序
其他3条回答
我们的想法是很简单的根在0的位置，后来假设的当前位置，然后我的左子节点2I +1，+2 2I右子节点。如根的左子节点的右子节点。左子节点，右子节点。定义一个空值没有子节点，如空。 假设交界处的三名成员：值，左，右 假定数组是全球性的，如果不是作为一个参数。 递归的实现是相对简单的： 无效btree2array（节点，指标） { ？？（节点？== NULL） ？？？？阵列[索引] =空; ？数组[索引] =节点值; ？？btree2array（节点左，指数* 2 + 1）; ？？btree2array（节点 - &指数* 2 + 2）; } 开头的呼叫句子： btree2array（根，0）; 此外，虚拟机，超低价团购 ？
}出栈的时候从各自两端出了。注意2个堆栈别溢出冲突。
我想你在开玩笑了
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁一个函数形如：
void f(float **p){
/* 想要在函数体中按二维数组的方式访问*/
&&& p[1][1] = 0;//c++用vc编译ok，运行出错（非法访问）
float **p; //其实这里的p并不是一个二位数组的指针，只不过是一个指向指针的指针
像你这样访问肯定是会出问题的。
float a[2][2]={0，1，2，3};
float **p=(float**)a;//强制将二维数组指针转为指向指针的指针
p[0][0]=*(*(p+0)+0)=**p；
p[0][1]=*(*(p+0)+1)；
对于p[0][0]：由于*p=0; ====& **p=*(0);引用地址为零的内存，必然是错误的。
对于p[0][1]=*(*p+1)====&*(4),引用了非法内存
同样，对于p[1][0]=*(1)，p[1][1]=*(5),均引用了非法内存
所以说，二位数组并不能简单的转换成指向指针的指针。
正确的指向二维数组的指针应该是:
float a[5][10];
float (*p)[10];//只需要定义为指向第二维的指针，忽略第一维
p[0][1]=a[0][1];
二级指针和二维数组并不等价。
二级指针是一个指向指针的指针
而二维数组其实就是一个指针，char a[3][4]； a是指向整个二维数组的首地址。它相当于(char *)[n],并不是char **;
所以不能直接：t=a;
要这样：t = (char **)a;
我们知道char array[]=&abcdef&; array是数组的首地址,
那么在二维数组中array当然也是数组的首地址,
看看这个定义char Array[][3] ={&ab&,&cd&,&ef&};
怎么知道的呢?定义这样一个数组,在vc调试窗口中
Array ---------0x
|------Array[0]---0x &ab&
|------Array[1]---0x &cd&
|------Array[2]---0x6432433A &ef&
已经很明白了,实际编译器是这样实现二维数组的,实际上Array是&一维指针数组&的首地址,其中每一个元素指针都对应一个字符串,那么好我们来看看是否可以这样来使用Array二维数组.
char **pArray = A编译器提示出错,怎么办呢?加个(char **)试试,仍然出错,设断看一下pArray的值和Array的值是相等的,但我们是否可以象使用Array那样来同样输出字符串呢?很明显是不行的,编译器不会把pArray+i处理成pArray+i*3寻找到第i个指针的地址,而只是简单的加了一个i.这说明编译器只做了很简单的将地址值赋给了pArray,而它实际没有任何意义.我们不能用它来访问任何数据.很奇怪吗?
再来看看这样定义char *p[] = {&ab&, &cd&, &ef&};定义了一个指针数组.char **sp =这样的用法经常看到,为什么这样就可以使用sp来访问字符串了呢,的确编译器在编译的时候识别出了sp是一个指向一维数组的指针的指针,那么我们就可以把它做为数组名来操纵整个数组了.
-----------------------------------------------------------------------------------------------------------------------------------
看如下例子：
#include &stdio.h&
int main(void)
&&&&&& int array[2][2] = {12, 15, 51, 54};
&&&&&& int **ptr = //错误
&&&&&& int **ptr = & //错误
&&&&&& int **ptr = &array[0][0]; //错误
&&&&&& ....
&&&&&& return 0;
错误在哪呢？
关于指针的说明：0） 指针只能指向一维数组。 1） C/C++标准中并没有 array[m][n] 这样的表达//array为指针变量； 2） 不能用一维指针或二维指针直接指向二维数组。如果要让一维指针指向二维数组，则我们必需告诉指针所指向的数组的最后一维包含多少个元素，即告诉指针我们将传递一个二维数组的首地址给指针。如上面的例子，应该这样来定义指针：int (*p)[4]；这样就可以用p=mat了；这是不是和我们上面说的"指针只能指向一维数组"相矛盾呢？不是的。其实指针指向的还是一维数组：这时我们是将每行当成一个元素！！指针即所谓的行指针。 3） 如果没有告诉指针所指向的数组是二维的（即定义行指针），显然指针不能接收二维数组名传来的地址，即p=mat的两边地址的类型不同，左边是一维的，右边是二维的。但是如果我们将二维数组看成是一维数组，那么这个一维数组的首地址是：mat[0]，所以我们可以用p=mat[0];这样指针对二维数组的引用将完全按照一维数组的引用方式来调用。
我们知道char array[]=&abcdef&; array是数组的首地址,　　那么在二维数组中array当然也是数组的首地址,　　看看这个定义char Array[][3] ={&ab&,&cd&,&ef&};　　怎么知道的呢?定义这样一个数组,在vc调试窗口中　　我们看到:　　Array ---------0x　　 |------Array[0]---0x &ab&　　 |------Array[1]---0x &cd&　　 |------Array[2]---0x6432433A &ef&　　已经很明白了,实际编译器是这样实现二维数组的,实际上Array是&一维指针数组&的首地址,其中每一个元素指针都　　对应一个字符串,那么好我们来看看是否可以这样来使用Array二维数组.　　char **pArray = A编译器提示出错,怎么办呢?加个(char **)试试,仍然出错,设断看一下pArray的值和Array　　的值是相等的,但我们是否可以象使用Array[i]那样来同样输出字符串呢?很明显是不行的,编译器不会把　　pArray+i处理成pArray+i*3寻找到第i个指针的地址,而只是简单的加了一个i.这说明编译器只做了很简单的将地址值赋给　　了pArray,而它实际没有任何意义.我们不能用它来访问任何数据.很奇怪吗?　　再来看看这样定义char *p[] = {&ab&, &cd&, &ef&};定义了一个指针数组.char **sp =这样的用法经常看到,为什么这样　　就可以使用sp[i]来访问字符串了呢,的确编译器在编译的时候识别出了sp是一个指向一维数组的指针的　　指针,那么我们就可以把它做为数组名来操纵整个数组了,c神奇的地方或者说精华的地方就在这里了,希望　　这篇文章对那些对指针或二级指针有疑惑的朋友能够有所帮助,这也是我blog里的第一篇文章,呵呵.
---------------------------------------------------------------------------------------------------------------
本来不想写什么的，但是看看，我觉得都没有我想要的答案，于是我像楼主推荐我的拙见。其实这个数组与指针的问题，要写的话，一句话，两句话是将不清楚的。
首先数组和指针的概念你没分清楚，数组的本质你没搞清楚。这是导致问题出现的根源。
int x[5]; 这个定义里面，我们说定义了一个数组x，此数组有5个数组元素，元素的类型为int类型。首先要问的是，x到底为什么东西? 我知道，在谭浩强的书上面说x是数组名，x代表了数组第一个元素的首地址。没错，x确实是数组的名字，x的值也确实是第一个数组元素的地址值。注意这里我们说x代表的值与数组第一个元素的地址值相等，但是并不是说他们的类型是一样的。那么x的类型到底是什么呢? 有人说就是int * 类型。有如下语句可以做证：
int *p=x; //这句话是正确的。
x的类型真是int *吗，我们说不是，因为下面的语句是不正确的：
int a=10;x=&a; // int *类型的变量时可以接受值的。所以x不是int*
那么我们可以猜测x的类型是不是 int *const呢。也就是说x是一个地址值不可以改变的指针。这句话貌似有点正确。但是请大家看看下面的例子：
int x[5]={0};int a=sizeof(x); // a的值到底是多少?实际上这里a的值是5*4=20我这里使用的编译器是VC++ 6.0 int类型数据占用4个字节空间，所以这里的道的是整个数组占用的字节数。 我们不是说x的类型是iint * const类型的吗，也就是x应该是一个指针类型，应该是4个字节的啊，为什么sizeof出来时整个数组占用的字节数呢。例如
sizeof(int *)这个的结果就是4。所以有此可以看出，x的类型并不是int*,也不是int * const。
int x[5];中的x到底是什么呢，我们说x是数组，此数组有5个元素，并且每个元素都是int类型。 我们有一个识别数据类型的规律例如：
//x类型为intint *x;//x类型为int *int **x;//x类型为int **int (*x)[10];//x类型为int(*)[10]实际上是指向数组的指针int (*x)(int ,int);//x的类型为int(*)(int,int)实际上是指向函数的指针
由此可以看出，一个符号是什么数据类型，我们只要在其定义的表达式中去掉符号本身，剩下的就是符号的类型了。照此推断，int x[5];中x的类型应该是 int [5]这个类型，可以看出此类型并不是int *类型。
那么int x[5];中的x可以这样赋值: int *p=x; 为什么呢，只能说这里面将x的类型隐式转换为了int *类型。所以这里是可以赋值的，因为进行了类型转换。 再请看下面的例子：
void function(int x[5]){& cout&&sizeof(x)&& //这里输出4}
为什么会输出4，而不是4*5呢，可以看出上面的函数形参实际上类型是int*，并不是数组类型，所以我们在定义函数的时候，下面的都是与上面等价的：
void function(int x[])//元素个数是多少可以省略{& cout&&sizeof(x)&& //这里输出4}
void function(int *x) //直接写成指针变量也没错{& cout&&sizeof(x)&& //这里输出4}
他们都是等价的。
那么我们看一个类似的问题：int x[5];int **p=&x; //为什么会报错？ 因为类型不匹配。
p的类型是int **,而&x的类型却不是int **。 &x的类型实际上是int(*)[5]，因为去的是x的地址，也就是说这个地址是数组的地址，并不是指向数组第一个元素的指针的指针(也就是二维指针)，而是整个数组的地址。所以我们可以改成下面的：int (*p)[5]=&x;//这就对了。
指向数组的指针，和指向数组元素的指针有什么不同？
我们说对于一个指针变量，要几点是我们必须注意的，例如int *p;我们要注意的是，p的类型是int*，p占用的空间4个字节，p指向的数据类型是int。p指向的数据类型占用4个字节。所以对于指针变量，我们要明白指针变量本身是占用空间的，本身是有类型的，其次指针变量所指向的空间是有类型的，是有空间的。
那么int *p; char *p1; 对于指针变量来说p,p1里面都放的是地址值，说白了就是一个数值，他们都占用4个字节的空间，但是他们的类型不一样，p里面的地址指向的是int类型的数据，p1指向的是char类型的数据，这主要体现在p++与p1++中他们在内存中移动的字节数是不一样的，我们假设int占4个字节，char占1个字节。那么对于p来说向前移动了4个字节，p1来说移动了一个字节。这就是他们的类型不同，导致运算过程中的不同。
int x[5];int (*p3)[5]; 此时p3指向数组x，那么p3++实际上向前移动了多少呢，可以算出移动了4*5个字节。也就是p3指向的是一个数组，是整个数组，所以p3移动的时候是将一个数组当做一个整体来看待的。所以向前移动了一整个数组的距离。
再看你的问题之前，我们来看一个类似的问题：
int a[2][3];int**p=&a; //这里我用&a来赋值行不行呢。是不行的。
这里为什么是错误的，原因就是因为&a的类型不是int**类型。所以类型不兼容，导致不能赋值，同时这两种类型是不可以相互转换的。 那么&a到底是一个什么样的类型呢。 我们说&a去的是整个数组的地址，那么&a自然就是指向整个数组的指针了。 int (*p)[2][3]=&a; 此时这样赋值才是正确的。如果我们要用a直接赋值，那该定义一个什么样的变量来接受它呢，首先要明白，数组名代表的地址类型是指向数组的第一个元素的指针，例如：
int a[10];int *p=a; 实际上这里与 int *p=&a[0];是等价的。因为指向a[0]的指针类型就是int*类型。& 那么&a的是去数组的地址，其类型是指向数组的指针，而不是指向数组第一个元素的指针，整个是要区别的，他们的类型就不一样。 int(*p)[10]=&a;
所以说这里的a和&a绝对不是同一个东西，虽然本质上他们的地址值是一样的，但是他们的类型不一样。就决定他们代表不同的意义。
那么刚刚说了对于下面的例子：int a[2][3];int (*p)[2][3]=&a;//我们可以定义这样的一个变量p来接受&a的值。
那么我们要接受a应该定义一个什么样的变量呢。a[2][3]是一个二维数组，可以看成是这样的a是一个数组，具有两个元素，分别为a[0],a[1]其中这两个元素的值a[0],a[1]他们的值又是一个具有3个元素的数组。此时我们可以将a[0],a[1]看成是数组名，那么a[0][0]就是数组a[0]的第0个元素了。对应关系如下：a[0] ----&& a[0][0],a[0][1],a[0][2]a[1] ----&& a[1][0],a[1][1],a[1][2]
那么a到底是什么，其实a数组有两个元素，a[0],a[1]，那么a的值自然就是其第一个元素的地址了，也就是&a[0]了。这是一个什么类型？& 我们知道如果我们将a[0]看成一个整体，例如我们用A来代替a[0],那么A[0],A[1]就相当于a[0][0],a[0][1] 。 此时A就是一个int类型的数组，&A，的类型实际上就是 int(*p)[3]这个类型。
所以下面的代码也是正确的：& int a[2][3]; int(*p)[3]=a; //所以对于你的问题，可以这样子。。
明白了吗？
-----------------------------------------------------------------------------
简单地说说，数组与指针的区别吧&& & int&& a[5];//组数a，a代表数组首地址，记住，是地址&& & int&& *p;//p，有一个四字节的空间，其中的内容是地址&& &&& & a&& =&& 5;//错误，因为a没有存储空间，它就是一个地址而已&& & p&& =&& 0x1234;//OK,p有存储空间&& &&& & 当数组与指针声明于函数参数时，&& & void&& fun(int&& a[]);&& & void&& fun(int*&& p);//p和a一个意思&&
--------------------------------------------------无论是二维，还是一维在内存中都是一样的，都是从低到高的地址序列&& 我认为函数应该这样定义&& void fun(char&& *p,&& int&& rows,int&& lines)//p是二维数组的地址（也就是第一个元素的地址）&& &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& //rows是行，lines是列
& 在&& fun()中，要自己编算法把它还原成二维数组&& &&& & 调用时可以这样&& & char&& a[2][2];&& & void&& main()&& & {&& &&&&&&& fun((char&& *)a,2,2);&& &&&&&&& //fun(&a[0][0],2,2);&& & }&& &&& 如果fun()函数传递的二维数组大小是固定的，可以这样声名&& & char fun(char a[5][5])& {&&&&& return a[3][3];&& & }&& &&& &&& & void main()&& & {&& &&&& char&& a[5][5];&& &&&& fun(a);&& & }&& &&& & 原则是：静态的申请数组时，必须给定数组的大小
----------------------------------------------------------转为1维的 双参数
void fnct ( double *p,int row, int col ) { && for(int i=0;i &row*i++) && { &&&&& cout & &p[i] & & && } }
int main() { & double A[3][2] = { {1},{2},{3} }; & fnct((double *)A,3,2);
& return 0; }------------------------------------------------------------1维通用接口void a(int *, int, int);
int main(void){&&&&&&& int c[2][5], b[6][8];&&&&&&& ......&&&&&&& a((int*)c, 2, 5);&&&&&& //使用数组c&&&&&&& .........&&&&&&& a((int*)b, 6, 8);&&&&&& //使用数组b&&&&&&& ....&&&&&&& return 0;}
void a(int *cpSource, int iRow, int iColumn){&&&&&& int **cpTemp,&&&&&& cpTemp = (int**)malloc(iRow*sizeof(int*));&&&&&& for(i=0; i&iR ++i) cpTemp[i] = cpSource+i*iC&&&&&& cpTemp[i][j] = ......&&&&&& //然后就可以cpTemp[i][j]这种形式使用了&&&&&& /*释放*/&&&&&& for(i=0; i&iR ++i) free(cpTemp[i]);&&&&&& free(cpTemp);&&&&&&}================================================1维 单参数const&& int&& N&& =&& 4;&& &&& & void&& Fun1(int&& (*a)[N])&& & {&& & }&& &&& & void&& Fun2(int&& a[][N])&& & {&& & }&& &&& & int&& main()&& & {&& & int&& a[N][N];&& & Fun1(a);&& & Fun2(a);&& & }
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：157271次
积分：1989
积分：1989
排名：第7657名
原创：22篇
转载：109篇
评论：47条
(2)(4)(3)(3)(1)(2)(8)(4)(1)(5)(6)(2)(2)(1)(8)(10)(4)(43)(21)(1)