C++博客-yx-随笔分类-模拟http://www.cppblog.com/csu-yx-2013/category/18794.htmlAlgorithm Study And So Onzh-cnSat, 14 Sep 2013 13:30:36 GMTSat, 14 Sep 2013 13:30:36 GMT60CSU OJ - 1183: 计算表达式的值http://www.cppblog.com/csu-yx-2013/archive/2012/03/19/168324.htmlyxyxMon, 19 Mar 2012 08:26:00 GMThttp://www.cppblog.com/csu-yx-2013/archive/2012/03/19/168324.htmlhttp://www.cppblog.com/csu-yx-2013/comments/168324.htmlhttp://www.cppblog.com/csu-yx-2013/archive/2012/03/19/168324.html#Feedback1http://www.cppblog.com/csu-yx-2013/comments/commentRss/168324.htmlhttp://www.cppblog.com/csu-yx-2013/services/trackbacks/168324.html后面居然把题目描述改了。所以，这个题无论怎么改，都是不对。因为，不知道是哪个坑爹的出题人，把数据里面加了\t，
难道出题人以为\t也是空格。估计，后面修改题目描述，也是发现这个问题后才改的。这可是还是哥了，改了无数多遍，
不处理非法数据就超时，略过非常数据当然直接WA了。好坑爹。
   计算表达式的值，以前严蔚敏书上就说用栈构造出来后缀表达式后再计算值。但是这个方法未免太那个了，首先太麻烦了，
虽然算法思路不麻烦。我的做法是直接递归计算即可。碰到左括号递归计算新的表达式，右括号作为函数终止条件。否则，按照
四则运算的优先级计算当前的表达式。递归算法中需要记录前一个运算符合的优先级，如果前一个运算符的优先级比现在碰到的
运算符的优先级高，那么就应该直接返回答案了，当前碰到的运算符的计算交给下一次循环好了。

   代码如下：

#include <stdio.h>
#define MAX (100 + 10)
char szData[MAX];

void TrimSpace(char* pszData)
{
    char* pszRead = pszData;
    char* pszWrite = pszData;
    while (*pszRead)
    {
        //由于数据中有\t,与先前题目描述不符合,不处理掉就直接超时了
        if (*pszRead != ' ' && *pszRead != '\t')
        {
            *pszWrite++ = *pszRead;
        }
        ++pszRead;
    }
    *pszWrite = '\0';
}

//nKind代表前一个运算符合的优先级,开始时是0,+-是1,*/是2
double Cal(char*& pszData, int nKind)
{
    double fAns = 0.0;
    while (*pszData && *pszData != ')')//表达式终止的条件是到达'\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;//移到')'后面
            return fAns;//一个括号内的是一个完整的表达式,因此直接返回
        }
    }
    
    return fAns;
}

int main()
{
    while (gets(szData))
    {
        TrimSpace(szData);
        char* pszData = szData;
        printf("%.4f\n", Cal(pszData, 0));
    }
}
   一个递归函数能计算出表达式的值，而且能处理优先级和括号，如果是以前的话，我应该是写不出来的。再把算法的实现细节改改，
应该也能计算出浮点数的表达式了。
   


yx 2012-03-19 16:26 发表评论
]]>生成排列的算法(POJ - 1256 和 POJ百练 - 1833)http://www.cppblog.com/csu-yx-2013/archive/2011/12/26/162852.htmlyxyxMon, 26 Dec 2011 07:53:00 GMThttp://www.cppblog.com/csu-yx-2013/archive/2011/12/26/162852.htmlhttp://www.cppblog.com/csu-yx-2013/comments/162852.htmlhttp://www.cppblog.com/csu-yx-2013/archive/2011/12/26/162852.html#Feedback0http://www.cppblog.com/csu-yx-2013/comments/commentRss/162852.htmlhttp://www.cppblog.com/csu-yx-2013/services/trackbacks/162852.html输入:一个序列s,该序列里面可能会有同样的字符,不一定有序
输出:打乱输入中的序列,可能产生的所有新的序列
题目2描述:
输入:一个序列s,该序列里面可能会有同样的字符,不一定有序 和 一个整数k
输出:该序列往后计算第k个序列,所有序列是以字典序排序的

如果会有序搜索的童鞋自然而然能立刻做出来第一个题目,可是第二个题目在s较长的情况下,却需要用模拟而不是搜索...
大家都知道STL里面有个泛函模版, prev_permutation和next_permutation,用法也很简单,实现的就是题目2的功能...
但是算法最好得靠自己想出来,自己想出来的才是自己的,碰到新的问题才能产生思想的火花...

废话少说,题目1的解法就是深搜,不过需要加上一个bool数组标记和一个函数确定不同字符之间的大小(有可能这个大小还不是Ascii码就能决定的),
大致描述下搜索过程,比如输入序列是12345,那么我搜索的过程大致是第一层按顺序选取1-5,进入第二层的时候也是按顺序选取1-5,
以此类推,但是每一层里面都只能选前面的层次没有选过的数,而且因为有重复字符,算法还必须保证每一层里面按顺序选取的字符必须是升序的,
熟悉顺序搜索和回溯的同学,很自然就会产生这样的想法...
POJ - 1256的代码如下:
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <algorithm>
#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的解法是模拟,功能类似与STL的那2个泛型模版函数,算法的大致过程是想办法从当前序列进入下一个刚好比其大或者刚好比其小的序列...很自然我们想到要把序列后面大的字符交和前面小的字符交换就会使序列变大,为了使其刚好变大,可以把交换后的字符从交换位置起至最后都排序一下,现在的问题是我们如何选取2个字符交换...正确的想法是,我们从最后面开始往前面看,寻找一个最长的递增序列,找到之后,我们只需要选取递增序列前面的那个字符chBefore和递增序列里面的一个最小的比chBefore大的字符交换即可...交换之后,将新的递增序列排序一下即可...
为什么这样做了,因为从后往前看的递增序列,是不能交换2个字符让当前序列变大的,所以必须选取最长递增序列前面的那个字符交换...

POJ百练 - 1833 的代码如下:
#include <stdio.h>
#include <string.h>
#include <algorithm>
#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:拨钟问题http://www.cppblog.com/csu-yx-2013/archive/2011/11/28/161082.htmlyxyxMon, 28 Nov 2011 11:55:00 GMThttp://www.cppblog.com/csu-yx-2013/archive/2011/11/28/161082.htmlhttp://www.cppblog.com/csu-yx-2013/comments/161082.htmlhttp://www.cppblog.com/csu-yx-2013/archive/2011/11/28/161082.html#Feedback0http://www.cppblog.com/csu-yx-2013/comments/commentRss/161082.htmlhttp://www.cppblog.com/csu-yx-2013/services/trackbacks/161082.htmlhttp://poj.grids.cn/practice/2814

这个题目可以枚举或者直接暴力。但是,这之前必须弄明白答案的解空间。。。也就是解可能的情况。。。很简单,一共有9种移动方案。也很了然的知道对于某种方案使用N次的效果等同于N%4的效果,也就是说某种方案只可能使用0,1,2,3次。。。一共有9种方案,那么一共就只有4^9种可能的解。。。这么小的解空间,无论用什么方法都不会超时了。。。暴力可以才用9重循环,或者深搜,当时觉得写9重循环是件很糗的事情,就果断深搜了。。。
如果这题才用枚举的方法的话,思考方式还是那样先确定假设解的部分情况,通过已经知道的规则确定解的其它情况,然后求出这个解,判断这个解是否满足题目要求。。。比如,我们可以枚举1,2,3号方案的情况,根据规则确定其它方案的使用情况,求出所有方案的使用情况后,判断假设的解是否满足要求就可以了...

我才用的是dfs+剪枝,这个题目其实题意或者说答案有误,因为答案是搜索找到第一个解,而不是所谓的最短序列的解,当然如果数据使得2者都是一样的话,那么题意就无误了...我的代码是假设找到的第一个就是最短序列的,这种情况下才能使用剪枝,因为找到一个解后就不需要继续找了...


代码如下:
#include <stdio.h>
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;
}

这道题其实我wa了近10次,原因就是Move和MoveBack写错了,没有移动nTimes次,而前面一直写成了1,昨晚wa得实在无语了...今天晚上检查才突然发现的...
这半个多月做了60道题了,都没有改动这低级的bug习惯...实在无语...递归,回溯,剪枝都写上了...唉...实在无语...还不如直接9重循环,多省心...真不该歧视某种方法的...


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