欧美久久综合性欧美,狠狠精品干练久久久无码中文字幕 ,伊人色综合久久天天

yx — Mon, 19 Mar 2012 08:26:00 GMT

题目意思很��单就是计��含括号的四则运��表辑ּ�的倹{��这个题目很坑爹�Q�刚做的时候，题目描述里面只说里面会有�I�格�Q?br />后面居然把题目描�q�改了。所以，�q�个题无论怎么改，都是不对。因为，不知道是哪个坑爹的出题�h�Q�把数据里面加了\t�Q?br />��N��出题��Z��为\t也是�I�格。估计，后面修改题目描述�Q�也是发现这个问题后才改的。这可是�q�是哥了�Q�改了无数多遍，
不处理非法数据就��时�Q�略�q�非常数据当然直接WA了。好坑爹�?br /> 计算表达式的��|��以前严蔚敏书上就说用栈构造出来后�~�表达式后再计��倹{��但是这个方法未免太那个了，首先太麻烦了�Q?br />虽然��法思�\不麻烦。我的做法是直接递归计算卛_��。碰到左括号递归计算新的表达式，��x��号作为函数终止条�?/strong>。否则，按照
四则�q�算的优先��计算当前的表辑ּ�。递归��法中需要记录前一个运��符合的优先�U�，如果前一个运��符的优先��比现在碰到的
�q�算�W�的优先�U�高�Q�那么就应该直接�q�回�{�案�?/strong>�Q�当前碰到的�q�算�W�的计算交给下一�ơ��@环好了�?br />
代码如下�Q?br />
#include
#define MAX (100 + 10)
char szData[MAX];

void TrimSpace(char* pszData)
{
    char* pszRead = pszData;
    char* pszWrite = pszData;
    while (*pszRead)
    {
        //�׃��数据中有\t,与先前题目描�q�C��W�合,不处理掉��q��接超时了
        if (*pszRead != ' ' && *pszRead != '\t')
        {
            *pszWrite++ = *pszRead;
        }
        ++pszRead;
    }
    *pszWrite = '\0';
}

//nKind代表前一个运��符合的优先�U?开始时�?,+-�?,*/�?
double Cal(char*& pszData, int nKind)
{
    double fAns = 0.0;
    while (*pszData && *pszData != ')')//表达式终止的条�g是到�?\0'或者碰到右括号
    {
        if (*pszData >= '0' && *pszData <= '9')
        {
            fAns = 10 * fAns + *pszData - '0';
            ++pszData;
        }
        else if (*pszData == '+')
        {
            if (nKind >= 1)
            {
                return fAns;
            }
            ++pszData;
            fAns += Cal(pszData, 1);
        }
        else if (*pszData == '-')
        {
            if (nKind >= 1)
            {
                return fAns;
            }
            ++pszData;
            fAns -= Cal(pszData, 1);
        }
        else if (*pszData == '*')
        {
            if (nKind >= 2)
            {
                return fAns;
            }
            ++pszData;
            fAns *= Cal(pszData, 2);
        }
        else if (*pszData == '/')
        {
            if (nKind >= 2)
            {
                return fAns;
            }
            ++pszData;
            fAns /= Cal(pszData, 2);
        }
        else if (*pszData == '(')
        {
            ++pszData;
            fAns = Cal(pszData, 0);
            ++pszData;//�U�d��')'后面
            return fAns;//一个括号内的是一个完整的表达�?因此直接�q�回
        }
    }

    return fAns;
}

int main()
{
    while (gets(szData))
    {
        TrimSpace(szData);
        char* pszData = szData;
        printf("%.4f\n", Cal(pszData, 0));
    }
}
一个递归函数能计��出表达式的��|��而且能处理优先��和括��P��如果是以前的话，我应该是写不出来的。再把算法的实现�l�节�Ҏ(gu��)��Q?br />应该也能计算出��Q�Ҏ(gu��)��的表辑ּ�了�?br />

yx 2012-03-19 16:26 发表评论

生成排列的算�?POJ - 1256 �?POJ癄�� - 1833)

yx — Mon, 26 Dec 2011 07:53:00 GMT
题目1描述:
输入:一个序列s,该序列里面可能会有同��L��字符,不一定有�?br />输出:打�ؕ输入中的序列,可能产生的所有新的序�?br />题目2描述:
输入:一个序列s,该序列里面可能会有同��L��字符,不一定有�?�?一个整数k
输出:该序列往后计��第k个序�?所有序列是以字典序排序�?br />
如果会有序搜索的童鞋自然而然能立��d��出来�W�一个题�?可是�W�二个题目在s较长的情况下,却需要用模拟而不是搜�?..
大家都知道STL里面有个泛函模版, prev_permutation和next_permutation,用法也很��?实现的就是题�?的功�?..
但是��法最好得靠自己想出来,自己惛_��来的才是自己�?��到新的问题才能产生思想的火�?..

废话��说,题目1的解法就是深�?不过需要加上一个bool数组标记和一个函数确定不同字�W�之间的大小(有可能这个大��还不是Ascii码就能决定的),
大致描述下搜索过�E?比如输入序列�?2345,那么我搜索的�q�程大致是第一层按��序选取1-5,�q�入�W�二层的时候也是按��序选取1-5,
以此�c�L��,但是每一层里面都只能选前面的层次没有选过的数,而且因�ؓ有重复字�W?��法�q�必��M��证每一层里面按��序选取的字�W�必��L��升序�?
熟�?zh��n)��序搜烦和回溯的同�?很自然就会��生这��L��x��...
POJ - 1256的代码如�?
#include
#include
#include
#include
#include
#define MAX (13 + 10)
using namespace std;
bool bUsed[MAX];
char szAns[MAX];
char szInput[MAX];
bool CmpChar(char chOne, char chTwo)
{
if (abs(chOne - chTwo) != 'a' - 'A')
{
return tolower(chOne) - tolower(chTwo) < 0;
}
return chOne - chTwo < 0;
}
bool Greater(char chOne, char chTwo)
{
if (abs(chOne - chTwo) != 'a' - 'A')
{
return tolower(chOne) - tolower(chTwo) > 0;
}
return chOne - chTwo > 0;
}
void Gen(int nDepth, int nLen)
{
if (nDepth == nLen)
{
szAns[nLen] = '\0';
printf("%s\n", szAns);
return;
}

char chLast = '\0';
for (int i = 0; i < nLen; ++i)
{
if (!bUsed[i] && Greater(szInput[i], chLast))
{
bUsed[i] = true;
szAns[nDepth] = szInput[i];
Gen(nDepth + 1, nLen);
bUsed[i] = false;
chLast = szInput[i];
}
}
}
int main()
{
int nCases;

scanf("%d", &nCases);
while (nCases--)
{
scanf("%s", szInput);
int nLen = strlen(szInput);
sort(szInput, szInput + nLen, CmpChar);
Gen(0, nLen);
}

return 0;
}
题目2的解法是模拟,功能�c�M��与STL的那2个泛型模版函�?��法的大致过�E�是惛_��法从当前序列�q�入下一个刚好比其大或者刚好比其小的序�?..很自然我们想到要把序列后面大的字�W�交和前面小的字�W�交换就会��序列变大,��Z��使其刚好变大,可以把交换后的字�W�从交换位置赯��最后都排序一�?现在的问题是我们如何选取2个字�W�交�?..正确的想法是,我们从最后面开始往前面�?��L��一个最长的递增序列,扑ֈ�之后,我们只需要选取递增序列前面的那个字�W�chBefore和递增序列里面的一个最��的比chBefore大的字符交换卛_��...交换之后,��新的递增序列排序一下即�?..
��Z��么这样做�?因�ؓ从后往前看的递增序列,是不能交�?个字�W�让当前序列变大�?所以必��选取最镉K��增序列前面的那个字�W�交�?..

POJ癄�� - 1833 的代码如�?
#include
#include
#include
#define MAX (1024 + 10)
using namespace std;
int nInput[MAX];
void GetNext(int* nInput, int nLen)
{
int i = nLen - 2;
while (i >= 0)
{
if (nInput[i] >= nInput[i + 1])
{
--i;
}
else
{
int k = i + 1;
for (int j = nLen - 1; j > i; --j)
{
if (nInput[j] > nInput[i] && nInput[j] < nInput[k])
{
k = j;
}
}
swap(nInput[i], nInput[k]);
sort(nInput + i + 1, nInput + nLen);
return;
}
}

sort(nInput, nInput + nLen);
}
int main()
{
int nCases;
scanf("%d", &nCases);
while (nCases--)
{
int nLen;
int nK;
scanf("%d%d", &nLen, &nK);
for (int i = 0; i < nLen; ++i)
{
scanf("%d", &nInput[i]);
}
for (int i = 0; i < nK; ++i)
{
GetNext(nInput, nLen);
}
for (int i = 0; i < nLen; ++i)
{
printf("%d%s", nInput[i], i == nLen - 1 ? "\n" : " ");
}
}
return 0;
}

yx 2011-12-26 15:53 发表评论

POJ癄�� - 2814:拨钟问题

yx — Mon, 28 Nov 2011 11:55:00 GMT
链接: http://poj.grids.cn/practice/2814

�q?/a>个题目可以枚举或者直接暴力。但�?�q�之前必��d��明白�{�案的解�I�间。。。也��是解可能的情况。。。很��?一共有9�U�移动方案。也很了然的知道对于某种�Ҏ(gu��)��使用N�ơ的效果�{�同于N%4的效�?也就是说某种�Ҏ(gu��)��只可能��?,1,2,3�ơ。。。一共有9�U�方�?那么一共就只有4^9�U�可能的解。。。这么小的解�I�间,无论用什么方法都不会��时了。。。暴力可以才�?重��@�?或者深�?当时觉得�?重��@环是件很�p�的事情,��果断深搜了。。�?br />如果�q�题才用枚�D的方法的�?思考方式还是那样先��定假设解的部分情况,通过已经知道的规则确定解的其它情�?然后求出�q�个�?判断�q�个解是否满��题目要求。。。比�?我们可以枚�D1,2,3��h��案的情况,�Ҏ(gu��)��规则��定其它�Ҏ(gu��)��的��用情�?求出所有方案的使用情况�?判断假设的解是否满��要求��可以了...

我才用的是dfs+剪枝,�q�个题目其实题意或者说�{�案有误,因�ؓ�{�案是搜索找到第一个解,而不是所谓的最短序列的�?当然如果数据使得2者都是一��L��?那么题意��无误了...我的代码是假设找到的�W�一个就是最短序列的,�q�种情况下才能��用剪�?因�ؓ扑ֈ�一个解后就不需要��l�找�?..

代码如下:
#include
int nMinTimes;
int nPath[40];
bool bFind = false;
char* szMoves[10] =
{
NULL,
"ABDE",
"ABC",
"BCEF",
"ADG",
"BDEFH",
"CFI",
"DEGH",
"GHI",
"EFHI"
};
bool IsPosOK(int* nPos)
{
for (int i = 0; i < 9; ++i)
{
if (nPos[i])
{
return false;
}
}
return true;
}
void Move(int nChoose, int nTimes, int* nPos)
{
if (nTimes > 0)
{
char* pszStr = szMoves[nChoose];
while (*pszStr)
{
nPos[*pszStr - 'A'] = (nPos[*pszStr - 'A'] + nTimes) % 4;
++pszStr;
}
}
}
void MoveBack(int nChoose, int nTimes, int* nPos)
{
if (nTimes > 0)
{
char* pszStr = szMoves[nChoose];
while (*pszStr)
{
nPos[*pszStr - 'A'] = (nPos[*pszStr - 'A'] - nTimes + 4) % 4;
++pszStr;
}
}
}
void Cal(int nChoose, int* nPos, int* nUsed, int nUsedTimes)
{
if (nChoose == 10)
{
if (IsPosOK(nPos) && !bFind)
{
nMinTimes = nUsedTimes;
for (int i = 0; i < nMinTimes; ++i)
{
nPath[i] = nUsed[i];
}
bFind = true;
}
return;
}
for (int i = 0; i <= 3; ++i)
{
Move(nChoose, i, nPos);
for (int j = 0; j < i; ++j)//攑օ�i�ơ的nChoose
{
nUsed[nUsedTimes + j] = nChoose;
}
if (!bFind)
{
Cal(nChoose + 1, nPos, nUsed, nUsedTimes + i);
}
MoveBack(nChoose, i, nPos);
}
}
int main()
{
int nPos[9];
int nUsed[40];
for (int i = 0; i < 9; ++i)
{
scanf("%d", &nPos[i]);
}
Cal(1, nPos, nUsed, 0);
for (int i = 0; i < nMinTimes; ++i)
{
printf("%d", nPath[i]);
if (i != nMinTimes - 1)
{
putchar(' ');
}
else
{
putchar('\n');
}
}

return 0;
}

�q�道题其实我wa了近10��?原因��是Move和MoveBack写错�?没有�U�d��nTimes��?而前面一直写成了1,昨晚wa得实在无语了...今天晚上��查才�H�然发现�?..
�q�半个多月做�?0道题�?都没有改动这低��的bug习惯...实在无语...递归,回溯,剪枝都写上了...�?..实在无语...�q�不如直�?重��@�?多省�?..真不该歧视某�U�方法的...

yx 2011-11-28 19:55 发表评论

欧美久久综合性欧美,狠狠精品干练久久久无码中文字幕 ,伊人色综合久久天天

生成排列的算�?POJ - 1256 �?POJ癄��� - 1833)

POJ癄��� - 2814:拨钟问题

生成排列的算�?POJ - 1256 �?POJ癄�� - 1833)

POJ癄�� - 2814:拨钟问题