不看会后悔的Windows XP之经验谈	简单快捷DIY实用家庭影院

编程编程再编程，看看最大的N是多少

楼主szws（克米帅）2005-03-02 21:30:47 在 C/C++ / C语言提问

用1,2,3,4,5,6,7,8,9算出连续的1,2,...,N。要求：只能用+,-,*,/，并且1-9这些数值

都必须用上。括号可以使用，编程编程再编程，看看最大的N是多少。
手算例子：
1=((1+2+3)/6+(5+4-8))/(9-7)
2=(1+2+3)/6+8-4-5+9-7
3=(5+4-8)*(1+2+3)/6+9-7
4=(1+2+3)/6+5+4-8+9-7 -->N=4
问题点数：50、回复次数：22Top

1 楼ganbaba（流光飞舞）回复于 2005-03-02 21:44:41 得分 0

学习Top

2 楼sankt（宠辱不惊,看庭前花开花落;去留无意,望天空云卷云舒.）回复于 2005-03-02 22:27:12 得分 0

不解啊
upTop

3 楼dongyuanzhang（阿林）回复于 2005-03-02 22:28:53 得分 0

比较难，有挑战性！Top

4 楼BlueGenie（蓝色妖精）回复于 2005-03-02 22:35:26 得分 0

用二叉树建立由1--9组成的算术表达式,根结点的值就是表达式的值.1--9是九个叶子.
根结点的左子树和右子树可以是:
左右
{1} {2,3,4,5,6,7,8,9}
{1,2} {3,4,5,6,7,8,9}
{1,3} {2,4,5,6,7,8,9}
........
........
........
另外,加法和乘法是可交换的.
好像看起来蛮烦的,不知道行不行?随便说说,呵呵!!
Top

5 楼pcboyxhy（-273.15℃）回复于 2005-03-02 22:38:08 得分 0

可以简单的递归+回溯Top

6 楼Meyino（大风）回复于 2005-03-03 09:10:43 得分 0

好玩
好题
Top

7 楼dongpy（51-->ARM）回复于 2005-03-03 10:21:58 得分 0

关注，还没想到好方法。Top

8 楼PepperYoung（阿原）回复于 2005-03-03 10:39:34 得分 20

我写了一个程序。大家看看是否正确。
如果全部遍历，要算好久。N 似乎比想象的要大。

code:

#include <stdio.h>
#include <conio.h>

#define _INLINE_ __inline

#define MAX_N 40000

int map[MAX_N] = {0};

int num[9][9];
int n = 8;

int max_n = 0;
int node = 0;

FILE *fplog;

void search();

_INLINE_ void record(int r)
{
int i, j;

if(r >= 0 && r < MAX_N)
{
int k;

if(map[r]) return;
map[r] = 1;

fprintf(fplog, "\n**%d:\n", r);
for(i = 8;i >= 0;i --)
{
for(j = 0;j <= i;j ++)
{
fprintf(fplog, "%d ", num[i][j]);
}
fprintf(fplog, "\n");
}

for(k = 1;k < MAX_N;k ++)
{
if(!map[k]) break;
}
if(k - 1 > max_n)
{
max_n = k - 1;
printf("current max N = %d\n", max_n);
}
}
}

_INLINE_ void copy(int p1, int p2)
{
int i, j = 1;

for(i = 0;i <= n;i ++)
{
if(i != p1 && i != p2)
{
num[n - 1][j ++] = num[n][i];
}
}
--n;
search();
++n;
}

void search()
{
int i, j;

if(n == 0)
{
record(num[0][0]);
return;
}

for(i = 0;i <= n;i ++)
{
if(n == 6)
{
++node;
printf("** %8.4f%%\n", node / 846.72);
}

for(j = 0;j < i;j ++)
{
int a = num[n][i], b = num[n][j];

num[n - 1][0] = a + b; copy(i, j);
num[n - 1][0] = a * b; copy(i, j);

num[n - 1][0] = a - b; copy(i, j);
num[n - 1][0] = b - a; copy(i, j);

if(b != 0 && a % b == 0) {
num[n - 1][0] = a / b; copy(i, j);
}
if(a != 0 && b % a == 0) {
num[n - 1][0] = b / a; copy(i, j);
}
}
}
}

int main()
{
int i;
for(i = 0;i <= n;i ++)
{
num[n][i] = i + 1;
}

if((fplog = fopen("log.txt", "w")) == NULL)
{
printf("error open log.txt\n");
}
else
{
search();
}
}Top

9 楼PepperYoung（阿原）回复于 2005-03-03 11:02:08 得分 0

我想的方法就是:
在9个数中任取两数做一次运算（+-*/）
结果和以前的7个数组成8个数。

再在8个数中任取两个做一次运算。同上变为7个。
以此类推，当只剩一个数时，记录下来结果。

例如：

1 2 3 4 5 6 7 8 9
3 3 4 5 6 7 8 9 (1 + 2 = 3)
6 4 5 6 7 8 9 (3 + 3 = 6)
10 5 6 7 8 9 (6 + 4 = 10)
15 6 7 8 9 (10 + 5 = 15)
-9 7 8 9 (6 - 15 = -9)
-2 8 9 (-9 + 7 = -2)
10 9 (8 - (-2) = 10)
1 (10 - 9 = 1)

程序中记录所有产生4万以内的数
如果结果 N > 4万那就把常量改大一点
Top

10 楼tianhai_tianhai（老海）回复于 2005-03-03 11:41:16 得分 5

PepperYoung的思路好！
学习中。
程序还没怎么看，

不过我开始的时候没想好怎么处理括号，
如果没有括号的话，用递归加遍历就可以解决了；
其实括号的作用可以抽象为任意两个数的优先结合；包含在上面这种从N到N-1的变化中；

第一步C(9,2)中选择，第二步C(8,2)选择，一直到最后C(2,2);
粗略的算一下复杂度： O( 4C(9,2) * 4C(8,2) * 4C(7,2)...* 4C(2,2) );
Top

11 楼BlueGenie（蓝色妖精）回复于 2005-03-03 11:43:55 得分 5

1,2,...,n共n个数,则这n个数的+,-,*,/组成的最大值为(1+2)*3*4*...*n
设表达式值为:expr = (expr1) op (expr2)
op
/ \
expr1 expr2
1).如果expr1或expr2中有一个为1,则max(expr) = expr1 + expr2
否则,max(expr) = expr1 * expr2
2).如果有表达式a1*a2*...*aj*...*ai + 1 和表达式(aj+1)*a1*a2*...*ai,其中aj=
min(a1,a2,...,ai), 则后一个表达式值更大.
因(aj+1)*a1*a2*...*ai = a1*a2*...*aj*...*ai + a1*a2*...*ai
3).表达式(aj+1)*a1*a2*...*ai和(ak+1)*a1*a2*...*ai,如果aj<ak则前一个表达式值更大
(aj+1)*a1*a2*...*ai = a1*a2*...*ak*...*aj*...*ai + a1*a2*...*ak*...*ai
(ak+1)*a1*a2*...*ai = a1*a2*...*ak*...*aj*...*ai + a1*a2*...*aj*...*ai
Top

12 楼sky911911（assda）回复于 2005-03-03 11:48:44 得分 0

帮助顶！！Top

13 楼PepperYoung（阿原）回复于 2005-03-03 11:58:33 得分 0

BlueGenie 的证明好

我理解的题目是：连续算出的最大数字
例如（只是例如）：
能够算出1-199，99999，不能算出200，那么最大数字是 199
不是 99999。

这样就复杂一些了，我的方法效率虽不高，但没关系，主要是不知道是否正确。
哪位大师帮忙看一看。

（我已经算到 N=12420 了），之前的连续自然数都能算出。Top

14 楼BlueGenie（蓝色妖精）回复于 2005-03-04 22:10:14 得分 20

我也用二叉树也了个,蛮烦的,效率也不高,有兴趣可以看看.
#include <iostream>
#include <vector>
#include <stdlib.h>

using namespace std;
#define SET_ZERO(coll) ((coll) = 0)
#define ADD_N(coll, n) ((coll) = (coll) | 0x1 << (n - 1))

struct Node {
int m_iValue ;
char* m_szExpr ;
Node* m_next ;
Node(int iValue = 0, char* szStr = NULL, Node* next = NULL)
: m_iValue(iValue), m_szExpr(szStr), m_next(next) {}
} ;

class ValueSet {
public:
ValueSet(int n) ;
~ValueSet() ;
void DestroyList(Node* pNode) ;
char* ValueExisted(int iIndex, int iValue) ;
bool AddValue(int iIndex, int iValue, char* psStr, int iLen) ;
private:
vector<Node*> m_data ;
} ;

ValueSet::ValueSet(int n) : m_data(n)
{
for (int i=0; i<m_data.size(); i++)
{
m_data[i] = new Node ;
}
}

ValueSet::~ValueSet()
{
for (int i=0; i<m_data.size(); i++)
{
DestroyList(m_data[i]) ;
m_data[i] = NULL ;
}
}

void ValueSet::DestroyList(Node* pNode)
{
Node* p ;

while (pNode)
{
p = pNode ;
pNode = p->m_next ;
delete p ;
}
}

char* ValueSet::ValueExisted(int iIndex, int iValue)
{
Node* p = m_data[iIndex - 1]->m_next ;

while (p && p->m_iValue > iValue) p = p->m_next ;

return p && p->m_iValue == iValue ? p->m_szExpr : NULL ;
}

bool ValueSet::AddValue(int iIndex, int iValue, char* psStr, int iLen)
{
Node* p = m_data[iIndex - 1] ;

while (p->m_next && p->m_next->m_iValue > iValue)
p = p->m_next ;

if (p->m_next && p->m_next->m_iValue == iValue)
{
return false ;
}

char* sz = new char[iLen + 1] ;
sz[iLen] = '\0' ;
strncpy(sz, psStr, iLen) ;
Node* q = new Node(iValue, sz, p->m_next) ;
if (!q) return false ;
p->m_next = q ;
return true ;
}

void InitIndex(int iDigit) ;
int MaxValue(int iDigit[]) ;
int LocateElem(int iDigit[], int iValue) ;
bool SplitIntoHalvesl(int iDigit[], int iLeft[], int& iCount, int iRight[]) ;
bool CanDeduced(int iValue, int iLeft, int iRight) ;
bool ExprExisted(int iValue, int iDigit[]) ;
bool ExprExistedWD(int iValue, int iDigit[]) ;

int g_iValue = 1 ;
char g_szExpr[81] ;
int g_iIndex = 0 ;
int g_iDigit = 0 ;
ValueSet g_set(512) ;

int main(int argc, char *argv[])
{
//iDigit[0]: the number of elements
int iDigit[] = { 9, 1, 2, 3, 4, 5, 6, 7, 8, 9 } ;
while (ExprExistedWD(g_iValue, iDigit))
{
cout << g_szExpr << " = " << g_iValue++ << endl ;
g_iIndex = 0 ;
memset(g_szExpr, 0, sizeof(g_szExpr)) ;
}

system("PAUSE") ;
return 0 ;
}

Top

15 楼BlueGenie（蓝色妖精）回复于 2005-03-04 22:11:38 得分 0

void InitIndex(int iDigit[])
{
SET_ZERO(g_iDigit) ;
for (int i=1; i<=iDigit[0]; i++)
ADD_N(g_iDigit, iDigit[i]) ;
}

//iValue can be deduced form iLeft and iRight just according to
//+, -, *
bool CanDeduced(int iValue, int iLeft, int iRight)
{
if (iLeft + iRight == iValue)
{
g_iIndex += sprintf(g_szExpr+g_iIndex, "(%d %c %d)",
iLeft, '+', iRight) ;
return true ;
}
if (iLeft * iRight == iValue)
{
g_iIndex += sprintf(g_szExpr+g_iIndex, "(%d %c %d)",
iLeft, '*', iRight) ;
return true ;
}
if (iLeft - iRight == iValue
|| iRight - iLeft == iValue)
{
g_iIndex += sprintf(g_szExpr+g_iIndex, "(%d %c %d)",
iLeft - iRight == iValue ?
iLeft, '-', iRight :
iRight, '-', iLeft) ;
return true ;
}
return false ;
}

int MaxValue(int iDigit[])
{
int iResult ;

if (iDigit[0] == 1) return iDigit[1] ;

if (iDigit[1] == 1)
iResult = iDigit[1] + iDigit[2] ;
else
iResult = iDigit[1] * iDigit[2] ;
for (int i=3; i<=iDigit[0]; i++)
iResult *= iDigit[i] ;

return iResult ;
}

int LocateElem(int iDigit[], int iValue)
{
int i ;

for (i=1; i<=iDigit[0] && iDigit[i]!=iValue; i++) ;

return i ;
}

bool SplitIntoHalves(int iDigit[], int iLeft[], int& iCount, int iRight[])
{
int iIndex, i, j ;

if (iCount < iDigit[0])
{
//search the index of leftest element need adjusting
for (i=iCount; i>0; i--)
{
iIndex = LocateElem(iDigit, iLeft[i]) ;
if (iDigit[0] - iIndex >= iCount - i + 1) break ;
}

if (i <= 0)
{
iCount ++ ;
if (iCount < iDigit[0])
{
int k ;
iLeft[0] = iCount ;
for (k=1; k<=iCount; k++)
iLeft[k] = iDigit[k] ;
iRight[0] = iDigit[0] - iCount ;
for (; k<=iDigit[0]; k++)
iRight[k-iCount] = iDigit[k] ;

return true ;
}
return false ;
}

for (j=i; j<=iLeft[0]; j++)
iLeft[j] = iDigit[++iIndex] ;

int iIndexL = 1 ;
int iIndexR = 1 ;
for (i=1; i<=iDigit[0]; i++)
{
if (iDigit[i] == iLeft[iIndexL])
iIndexL ++ ;
else
iRight[iIndexR++] = iDigit[i] ;
}

return true ;
}
return false ;
}

bool CanAdd(int iValue, int iLeft[], int iRight[])
{
bool bExisted = false ;
int iIndex = g_iIndex ;
int iMaxLeft, iMaxRight ;
char szSub[81], *psz ;

iMaxLeft = MaxValue(iLeft) ;
iMaxRight = MaxValue(iRight) ;

for (int i=1; i<iValue; i++)
{
if (iMaxLeft < i || iMaxRight < iValue - i)
break ;

g_szExpr[g_iIndex++] = '(' ;
int k = g_iIndex ;
InitIndex(iLeft) ;
if (!(psz = g_set.ValueExisted(g_iDigit, i)))
{
if (!ExprExisted(i, iLeft))
{
g_iIndex = iIndex ;
continue ;
}
InitIndex(iLeft) ;
strncpy(szSub, g_szExpr + k, g_iIndex - k) ;
g_set.AddValue(g_iDigit, i, szSub, g_iIndex - k) ;
}
else
g_iIndex += sprintf(g_szExpr + g_iIndex, "%s", psz) ;

g_iIndex += sprintf(g_szExpr + g_iIndex, " %c ", '+') ;
int j = g_iIndex ;
InitIndex(iRight) ;
if (!(psz = g_set.ValueExisted(g_iDigit, iValue - i)))
{
if (bExisted = ExprExisted(iValue - i, iRight))
{
InitIndex(iRight) ;
strncpy(szSub, g_szExpr + j, g_iIndex - j) ;
g_set.AddValue(g_iDigit, iValue - i, szSub, g_iIndex - j) ;
}
}
else
g_iIndex += sprintf(g_szExpr + g_iIndex, "%s", psz) ;
if (psz || bExisted)
{
g_szExpr[g_iIndex++] = ')' ;
return true ;
}
g_iIndex = iIndex ;
}
return false ;
}

bool CanMultiply(int iValue, int iLeft[], int iRight[])
{
bool bExisted = false ;
int iIndex = g_iIndex ;
int iMaxLeft, iMaxRight ;
char szSub[81], *psz ;

iMaxLeft = MaxValue(iLeft) ;
iMaxRight = MaxValue(iRight) ;

for (int i=1 ; i<=iValue; i++)
{
if (iMaxLeft < i) break ;

if (iValue % i || iMaxRight * i < iValue)
continue ;

InitIndex(iLeft) ;
if (!(psz = g_set.ValueExisted(g_iDigit, i)))
{
if (!ExprExisted(i, iLeft))
{
g_iIndex = iIndex ;
continue ;
}
InitIndex(iLeft) ;
strncpy(szSub, g_szExpr + iIndex, g_iIndex - iIndex) ;
g_set.AddValue(g_iDigit, i, szSub, g_iIndex - iIndex) ;
}
else
g_iIndex += sprintf(g_szExpr + g_iIndex, "%s", psz) ;

g_iIndex += sprintf(g_szExpr + g_iIndex, " %c ", '*') ;
int j = g_iIndex ;
InitIndex(iRight) ;
if (!(psz = g_set.ValueExisted(g_iDigit, iValue / i)))
{
if (bExisted = ExprExisted(iValue /i, iRight))
{
InitIndex(iRight) ;
strncpy(szSub, g_szExpr + j, g_iIndex - j) ;
g_set.AddValue(g_iDigit, iValue / i, szSub, g_iIndex - j) ;
}
}
else
g_iIndex += sprintf(g_szExpr + g_iIndex, "%s", psz) ;
if (psz || bExisted)
{
return true ;
}
g_iIndex = iIndex ;
}
return false ;
}

bool CanMinus(int iValue, int iLeft[], int iRight[])
{
bool bExisted = false ;
int iIndex = g_iIndex ;
int iMaxLeft, iMaxRight ;
char szSub[81], *psz ;

iMaxLeft = MaxValue(iLeft) ;
iMaxRight = MaxValue(iRight) ;

for (int i=iMaxLeft ; i>=iValue; i--)
{
if (iMaxLeft - i > iMaxRight)
break ;

g_szExpr[g_iIndex++] = '(' ;
int k = g_iIndex ;
InitIndex(iLeft) ;
if (!(psz = g_set.ValueExisted(g_iDigit, i)))
{
if (!ExprExisted(i, iLeft))
{
g_iIndex = iIndex ;
continue ;
}
InitIndex(iLeft) ;
strncpy(szSub, g_szExpr + k, g_iIndex - k) ;
g_set.AddValue(g_iDigit, i, szSub, g_iIndex - k) ;
}
else
g_iIndex += sprintf(g_szExpr + g_iIndex, "%s", psz) ;

g_iIndex += sprintf(g_szExpr + g_iIndex, " %c ", '-') ;
int j = g_iIndex ;
InitIndex(iRight) ;
if (!(psz = g_set.ValueExisted(g_iDigit, i - iValue)))
{
if (bExisted = ExprExisted(i - iValue, iRight))
{
InitIndex(iRight) ;
strncpy(szSub, g_szExpr + j, g_iIndex - j) ;
g_set.AddValue(g_iDigit, i - iValue, szSub, g_iIndex - j) ;
}
}
else
g_iIndex += sprintf(g_szExpr + g_iIndex, "%s", psz) ;
if (psz || bExisted)
{
g_szExpr[g_iIndex++] = ')' ;
return true ;
}
g_iIndex = iIndex ;
}
return false ;
}

Top

16 楼BlueGenie（蓝色妖精）回复于 2005-03-04 22:13:14 得分 0

//For the result of a divide operation can be a float point number,
//so Split the expression into halves by "/", each part of which
//can only take operation +, -, *
bool ExprExisted(int iValue, int iDigit[])
{
bool bExisted = false ;
int iCount = 1 ;
int iIndex = g_iIndex ;
int iLeft[10] = {1}, iRight[10] = {0} ;
char szSub[81] ;

iLeft[1] = iDigit[1] ;
iRight[0] = iDigit[0] - 1 ;
for(int i= 2; i<=iDigit[0]; i++)
iRight[i-1] = iDigit[i] ;

if (iDigit[0] == 1)
{
bExisted = (iValue == iDigit[1]) ;
if (bExisted)
{
g_iIndex += sprintf(g_szExpr+g_iIndex, "%d", iDigit[1]) ;
InitIndex(iDigit) ;
g_set.AddValue(g_iDigit, iValue, g_szExpr + iIndex,
g_iIndex - iIndex) ;
}
return bExisted ;
}
if (iDigit[0] == 2)
{
if (bExisted = CanDeduced(iValue, iDigit[1], iDigit[2]))
{
InitIndex(iDigit) ;
g_set.AddValue(g_iDigit, iValue, g_szExpr + iIndex,
g_iIndex - iIndex) ;
}
return bExisted ;
}

//for the expression not involving "/"
do
{
bExisted = CanAdd(iValue, iLeft, iRight)
|| CanMinus(iValue, iLeft, iRight)
|| CanMultiply(iValue, iLeft,iRight) ;
if (bExisted)
{
InitIndex(iDigit) ;
strncpy(szSub, g_szExpr + iIndex, g_iIndex - iIndex) ;
g_set.AddValue(g_iDigit, iValue, szSub, g_iIndex - iIndex) ;
return true ;
}
g_iIndex = iIndex ;
} while (SplitIntoHalves(iDigit, iLeft, iCount, iRight)) ;

return false ;
}

//Version with divide operation
bool ExprExistedWD(int iValue, int iDigit[])
{
bool bExisted = false ;
int iIndex = g_iIndex ;
int iLeft[10] = {1};
int iRight[10] = {0} ;
char szSub[81], *psz ;

iLeft[1] = iDigit[1] ;
iRight[0] = iDigit[0] - 1 ;
for (int i=2; i<=iDigit[0]; i++)
iRight[i-1] = iDigit[i] ;

//for the expression without '/'
bExisted = ExprExisted(iValue, iDigit) ;
if (bExisted) return true ;

g_iIndex = iIndex ;

//for the expression involving "/"
int iCount = 1 ;
do
{
for (int i=iValue; i <= MaxValue(iLeft)
&& i / iValue <= MaxValue(iRight); i+=iValue)
{
InitIndex(iLeft) ;
if (!(psz = g_set.ValueExisted(g_iDigit, i)))
{
if (!ExprExisted(i, iLeft))
{
g_iIndex = iIndex ;
continue ;
}
InitIndex(iLeft) ;
strncpy(szSub, g_szExpr + iIndex, g_iIndex - iIndex) ;
g_set.AddValue(g_iDigit, i, szSub, g_iIndex - iIndex) ;
}
else
g_iIndex += sprintf(g_szExpr + g_iIndex, "%s", psz) ;

g_iIndex += sprintf(g_szExpr+g_iIndex, " %c ", '/') ;

int j = g_iIndex ;
InitIndex(iRight) ;
if (!(psz = g_set.ValueExisted(g_iDigit, i / iValue)))
{
if (bExisted = ExprExisted(i / iValue, iRight))
{
InitIndex(iRight) ;
strncpy(szSub, g_szExpr + j, g_iIndex - j) ;
g_set.AddValue(g_iDigit, i / iValue, szSub, g_iIndex - j) ;
}
}
else
g_iIndex += sprintf(g_szExpr + g_iIndex, "%s", psz) ;
if (psz || bExisted)
{
return true ;
}
}
g_iIndex = iIndex ;
} while (SplitIntoHalves(iDigit, iLeft, iCount, iRight)) ;

return false ;
}Top

17 楼yuanxiabest2000（yuanxia）回复于 2005-03-04 22:32:21 得分 0

不好意思,补上一段,如下:

bool ExprExisted(int iValue, int iDigit[])
{
bool bExisted = false ;
int iCount = 1 ;
int iIndex = g_iIndex ;
int iLeft[10] = {1}, iRight[10] = {0} ;
char szSub[81] ;

iLeft[1] = iDigit[1] ;
iRight[0] = iDigit[0] - 1 ;
for(int i= 2; i<=iDigit[0]; i++)
iRight[i-1] = iDigit[i] ;

//NOTE: THE FOLLOWING CODE NEEDS APPENDING
InitIndex(iDigit) ;
char * ps ;
if (ps = g_set.ValueExisted(g_iDigit, iValue))
{
strcpy(g_szExpr, ps) ;
return true ;
}
..............
..............
..............Top

18 楼tenix（特尼克斯）回复于 2005-03-05 00:41:27 得分 0

该题目可以这样分解：
1、给出一个数N，要求用1~9这9个数，用+-*/把这个数算出来。
2、遍历法解答：想把这9个数做全排列，有9!种，然后在每一种的这9个数之间放入这4种符号，一共就有(9!)*(4^8)，然后加上括号，8个符号按照理论上的优先顺序就有8!种，那么一共是(9!)*(4^8)*(8!)=113747151468625920，数字非常大，但并不一定要全部遍历，一旦等于给定的N就可以退出，做N+1了。
Top

19 楼cao12m（★草上飞★）回复于 2005-03-05 02:27:07 得分 0

最大的数字莫过于全乘 1*2*3*4*5*。。。*9 一定在这以内这是上限Top

20 楼cao12m（★草上飞★）回复于 2005-03-05 02:28:14 得分 0

什么跟什么遍力啊我怎么看不懂Top

21 楼ybt631（默默耕耘!）回复于 2005-03-05 02:46:23 得分 0

可能会存在断层的现象Top

22 楼searoom（海龙）回复于 2005-03-05 09:26:51 得分 0

................Top