C++博客-yx-随笔分类-搜索http://www.cppblog.com/csu-yx-2013/category/18793.htmlAlgorithm Study And So Onzh-cnFri, 13 Sep 2013 01:08:32 GMTFri, 13 Sep 2013 01:08:32 GMT60hdu 4294 Multiple 数论 + bfshttp://www.cppblog.com/csu-yx-2013/archive/2012/09/18/191097.htmlyxyxTue, 18 Sep 2012 05:27:00 GMThttp://www.cppblog.com/csu-yx-2013/archive/2012/09/18/191097.htmlhttp://www.cppblog.com/csu-yx-2013/comments/191097.htmlhttp://www.cppblog.com/csu-yx-2013/archive/2012/09/18/191097.html#Feedback0http://www.cppblog.com/csu-yx-2013/comments/commentRss/191097.htmlhttp://www.cppblog.com/csu-yx-2013/services/trackbacks/191097.html   题意是给出N,K，求M，使得M是N的正倍数，而且M用K进制表示后所需要的不同数字(0,1,2,3,...,k-1)最少，如果有多组
这样的情况，求出最小的M。
   很数学的题意。用到了一个结论，就是任意数字的正倍数均可以用不超过2个不同数字的数得到。
   证明如下：
   任意数M % N 总共有N种结果，假如有N+1个不同的M，那么肯定有2个M对N取模后的结果是相同，这个是所谓鸽巢原理。
那么，我取a,aa,aaa,...,aaaaaaaaaa....，总共N+1个，同样满足上面的结论。那么我取那2个对N取模相同的数字相减得到
数字aaaaa...000....，这个数字肯定是N的倍数。
   综合上面的证明，只能得到2个数字肯定能表示N的倍数。但是不能说形式就是aaaaa...000....。

   到了这里我还是一点思路都没有，一点都不知道怎么搜索。。。
   想了1个多小时，无头绪，问过了这题的同学，还是无头绪。看解题报告，他们的代码写得太牛了，完全看不懂，无头绪。
也许也是我对bfs理解太浅，才看不懂他们的搜索代码。而且，我连可以搜索的地方都没有找到，都不知道搜什么了。
   想了好久，昨天吃饭的时候，终于发现可以对余数进行搜索。
   对于任意的N，其余数就是范围是[0, N -1]。这个其实就可以代表状态了，或者代表bfs中的点了。从当前余数转移到其它
余数的是MOD * K +  A 或者 MOD * K + B，如果要转移到得余数以前没被搜过，那就可以转移过去。这个刚好就是一个
优化了。也可以看成是子问题了。但是，dfs完全不行。刚开始用dfs，绝对的超时。
   用dfs也是我对思路理解不深，侥幸认为能过。。。后面发现，这题完全和bfs吻合。[0, N -1]刚好代表N个点，我要通过
从外面的一个点，最短的遍历到点0，可以bfs或者最短路算法。这题我觉得还有个难点就是保存答案，因为答案最长的长度
可能是N(N<=10000)，所以把答案直接放到节点里面肯定不行的。但是，我还仔细看过算法导论。因此想到了可以利用bfs
搜索出来的那颗树或者最短路算法跑出来的那颗树，从目标节点逆序寻找答案，找到出发节点之后，再把答案reverse一下就行了。
   这题还得注意0不能是N的倍数，所以注意bfs(0,i)这种情况的处理。

   代码如下：
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
using namespace std;

const int MAX_N = 10010;
int nOut[MAX_N];
int nOLen;
int nAns[MAX_N];
int nALen;
bool bMod[MAX_N];
int nFather[MAX_N];
int nChoose[MAX_N];
int nN;
int nK;
bool bFind;

int Cmp(int* A, int nLA, int* B, int nLB)
{
    if (nLA != nLB)
    {
        return nLA - nLB;
    }
    for (int i = 0; i < nLA; ++i)
    {
        if (A[i] != B[i])
        {
            return A[i] - B[i];
        }
    }
    return 0;
}

void Bfs(int nA, int nB)
{
    memset(bMod, false, sizeof(bMod));
    queue<int> que;
    que.push(0);
    int nTemp;
    bool bFirst = true;
    bFind = false;
    
    if (nA > nB)swap(nA, nB);
    //printf("nA:%d, nB:%d\n", nA, nB);
    while (!que.empty())
    {
        //printf("nMod:%d\n", que.front());
        int nMod = que.front();
        que.pop();
        if (nMod == 0)
        {
            if (bFirst)bFirst = false;
            else
            {
                bFind = true;
                break;
            }
        }
        
        nTemp = (nMod * nK + nA) % nN;
        if (!(nMod == 0 && nA == 0) && !bMod[nTemp])
        {
            nFather[nTemp] = nMod;
            nChoose[nTemp] = nA;
            que.push(nTemp);
            bMod[nTemp] = true;
            //printf("nTemp:%d\n", nTemp);
        }
        if (nA == nB)continue;
        nTemp = (nMod * nK + nB) % nN;
        if (!bMod[nTemp])
        {
            nFather[nTemp] = nMod;
            nChoose[nTemp] = nB;
            que.push(nTemp);
            bMod[nTemp] = true;
            //printf("nTemp:%d\n", nTemp);
        }
    }
    
    if (bFind)
    {
        int nF = 0;
        nALen = 0;
        do
        {
            nAns[nALen++] = nChoose[nF];
            nF = nFather[nF];
        } while (nF);
        reverse(nAns, nAns + nALen);
    }
}

int main()
{
    while (scanf("%d%d", &nN, &nK) == 2)
    {
        bool bOk = false;
        nOLen = 0;
        for (int i = 1; i < nK; ++i)
        {
            Bfs(i, i);
            if (bFind)
            {
                if (nOLen == 0 || Cmp(nOut, nOLen, nAns, nALen) > 0)
                {
                    nOLen = nALen;
                    memcpy(nOut, nAns, sizeof(int) * nALen);
                }
                bOk = true;
            }
        }
        if (!bOk)
            for (int i = 0; i < nK; ++i)
            {
                for (int j = i + 1; j < nK; ++j)
                {
                    Bfs(i, j);
                    if (bFind)
                    {
                        if (nOLen == 0 || Cmp(nOut, nOLen, nAns, nALen) > 0)
                        {
                            nOLen = nALen;
                            memcpy(nOut, nAns, sizeof(int) * nALen);
                        }
                    }
                }
            }
        for (int k = 0; k < nOLen; ++k)
        {
            printf("%d", nOut[k]);
        }
        printf("\n");
    }

    return 0;
}


yx 2012-09-18 13:27 发表评论
]]>uva 657 - The die is casthttp://www.cppblog.com/csu-yx-2013/archive/2012/07/14/183453.htmlyxyxSat, 14 Jul 2012 13:16:00 GMThttp://www.cppblog.com/csu-yx-2013/archive/2012/07/14/183453.htmlhttp://www.cppblog.com/csu-yx-2013/comments/183453.htmlhttp://www.cppblog.com/csu-yx-2013/archive/2012/07/14/183453.html#Feedback0http://www.cppblog.com/csu-yx-2013/comments/commentRss/183453.htmlhttp://www.cppblog.com/csu-yx-2013/services/trackbacks/183453.html
30 15 
.............................. 
..............................
 ...............*.............. 
...*****......****............ 
...*X***.....**X***...........
 ...*****....***X**............
 ...***X*.....****.............
 ...*****.......*..............
 ..............................
 ........***........******.....
 .......**X****.....*X**X*.....
 ......*******......******..... 
.....****X**.......*X**X*..... 
........***........******..... 
..............................
比如上面这个30 * 15的图片里面，一共有四个区域，*作为区域的底色，然后是求区域里面有多少个X的块。这个题单纯dfs的话，很没办法，因为无法一次性把连接在一起的X都搜索了。比如，
5 5
XXX*X 
XXX*X 
..... 
X***X 
XX*** 
的时候，dfs很明显就会出现问题，因为会先离开X块，再次回到X块，计数就会出现问题了。因此只能遇到X的时候，进行一次bfs，将与其相连接的X全部搜索掉。。。并且找到与当前X块相连接的一个*的位置，如果有这样的位置，就继续进行dfs。

代码如下：
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;

int nW, nH;
char szData[100][100];
bool bVisit[100][100];
int nNum;
int nDice[100];
int nAdd[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};

bool IsPosOk(int i, int j)
{
    return i >= 0 && i < nH && j >= 0 && j < nW;
}

struct POS
{
    int nI;
    int nJ;
};

bool Bfs(int& nI, int& nJ)
{
    bool bRet = false;
    queue<POS> qp;
    POS pos = {nI, nJ};
    int i = nI, j = nJ;

    qp.push(pos);
    while (qp.empty() == false)
    {
        POS head = qp.front();
        qp.pop();

        for (int m = 0; m < 4; ++m)
        {
            int nNextI = head.nI + nAdd[m][0];
            int nNextJ = head.nJ + nAdd[m][1];

            if (IsPosOk(nNextI, nNextJ) && bVisit[nNextI][nNextJ] == false)
            {
                if (szData[nNextI][nNextJ] == 'X')
                {
                    bVisit[nNextI][nNextJ] = true;
                    POS pos = {nNextI, nNextJ};
                    qp.push(pos);
                }
                else if (szData[nNextI][nNextJ] == '*')
                {
                    bRet = true;
                    nI = nNextI;//   这里是返回新的dfs位置
                    nJ = nNextJ;
                }
            }
        }
    }
    
    return bRet;
}

void dfs(int i, int j, int nNum)
{
    bVisit[i][j] = true;
    if (szData[i][j] == 'X')
    {
        nDice[nNum]++;
        bool bDfs = Bfs(i, j);//扩散掉当前连通的所有'X'
        if (bDfs == false)
        {
            return;
        }
        else
        {
            dfs(i, j, nNum);
        }
    }

    for (int m = 0; m < 4; ++m)
    {
        int nNextI = i + nAdd[m][0];
        int nNextJ = j + nAdd[m][1];

        if (IsPosOk(nNextI, nNextJ) && bVisit[nNextI][nNextJ] == false
                && szData[nNextI][nNextJ] != '.')
        {
            dfs(nNextI, nNextJ, nNum);
        }
    }
}

int main()
{
    int nCases = 1;

    while (scanf("%d%d", &nW, &nH), nW + nH)
    {
        for (int i = 0; i < nH; ++i)
        {
            scanf("%s", szData[i]);
        }
        memset(bVisit, false, sizeof(bVisit));
        memset(nDice, 0, sizeof(nDice));
        nNum = 0;

        for (int i = 0; i < nH; ++i)
        {
            for (int j = 0; j < nW; ++j)
            {
                if (szData[i][j] == 'X' && bVisit[i][j] == false)
                {
                    dfs(i, j, nNum);
                    nNum++;
                }
            }
        }
        sort(nDice, nDice + nNum);

        printf("Throw %d\n", nCases++);
        for (int i = 0; i < nNum; ++i)
        {
            printf("%d%s", nDice[i], i == nNum - 1 ? "\n" : " ");
        }
        printf("\n");
    }

    return 0;
}


yx 2012-07-14 21:16 发表评论
]]>Uva 10132 - File Fragmentationhttp://www.cppblog.com/csu-yx-2013/archive/2012/03/30/169548.htmlyxyxFri, 30 Mar 2012 10:52:00 GMThttp://www.cppblog.com/csu-yx-2013/archive/2012/03/30/169548.htmlhttp://www.cppblog.com/csu-yx-2013/comments/169548.htmlhttp://www.cppblog.com/csu-yx-2013/archive/2012/03/30/169548.html#Feedback1http://www.cppblog.com/csu-yx-2013/comments/commentRss/169548.htmlhttp://www.cppblog.com/csu-yx-2013/services/trackbacks/169548.html成N张一样的纸。我历来思维比较随便，不是很严谨的那种。然后，想了一下发现一定会有大于等于N张破纸片是符合前半部分模式的。
那么，可以建一个字典树，把所有的是前半张纸的找出来。然后根据这前半张纸，找出剩下的后半张纸（因为知道一整张纸的长度，所以知道
剩下的半张纸的长度）。但是写出来就发现这样不严谨，是不对的。因为单纯根据已经找出来的前半张纸，无法确定后半张纸（事实上，只能
确定其长度而已）。
   那么只能找其它方法了，再检查了下数据范围，发现比较小，那么意味着可以暴力求解了。好吧，那就深搜吧。我把所有的破纸片按照它们
的长度分成一些集合，对于长度为len的纸片集合，只要与长度为nAnsLen - len的纸片集合进行搜索匹配，找出一个可行的解即可了。我又
想当然的认为只要匹配一对集合即可了，那么很显然又是错的了。好吧，我只能对所有集合进行匹配了。对每一对集合进行深搜回溯来匹配待
选的Ans，而这个Ans是从第一对集合中搜索出来的答案。
   代码写得很冗长，很复杂，差不多200多行了。真的是水平有限，这种题很明显应该有更方便的解法的，而且我的代码应该不至于写得这么
乱的。
   后面还是错了很多次，发现了很多bug，比如我如果搜索长度为nAnsLen/2的集合时就必须进行特殊处理。还有最后一个样例后面不能输
出’\n'，而且uvaoj不能对这个换行判PE，一直是WA，实在是让人崩溃。
   
#include <stdio.h> 
#include <string.h>
#define MAX (256 + 10)
#define MAX_NUM (150)

char szLines[MAX_NUM][MAX];
char szAns[MAX];

struct SET
{
    int nNum;
    char szLines[MAX_NUM][MAX];
    bool bUsed[MAX];
};

SET sets[MAX];
char szTmpOne[MAX];
char szTmpTwo[MAX];
int nAnsLen;
bool bFind;

void dfs(int nI, int nNum)
{
    if (nNum == 0)
    {
        bFind = true;
    }
    else
    {
        for (int i = 0; i < sets[nI].nNum && !bFind; ++i)
        {
            for (int j = 0; j < sets[nAnsLen - nI].nNum && !bFind; ++j)
            {
                if (nI == nAnsLen - nI && i == j)
                {
                    continue;
                }

                if (!sets[nI].bUsed[i] && !sets[nAnsLen - nI].bUsed[j])
                {
                    strcpy(szTmpOne, sets[nI].szLines[i]);
                    strcat(szTmpOne, sets[nAnsLen - nI].szLines[j]);
                    strcpy(szTmpTwo, sets[nAnsLen - nI].szLines[j]);
                    strcat(szTmpTwo, sets[nI].szLines[i]);

                    //printf("%s\n", szAns);
                    if (strcmp(szTmpOne, szAns) == 0 || strcmp(szTmpTwo, szAns) == 0)
                    {
                        sets[nI].bUsed[i] = sets[nAnsLen - nI].bUsed[j] = true;
                        if (!bFind)
                        {
                            if (nI == nAnsLen - nI)
                            {
                                dfs(nI, nNum - 2);
                            }
                            else
                            {
                                dfs(nI, nNum - 1);
                            }
                        }
                        sets[nI].bUsed[i] = sets[nAnsLen - nI].bUsed[j] = false;
                    }
                }
            }
        }
    }
}

bool Find(int nI)
{
    bFind = false;
    for (int i = 0; i < sets[nI].nNum && !bFind; ++i)
    {
        for (int j = 0; j < sets[nAnsLen - nI].nNum && !bFind; ++j)
        {
            if (nI == nAnsLen - nI && i == j)
            {
                continue;
            }

            sets[nI].bUsed[i] = true;
            sets[nAnsLen - nI].bUsed[j] = true;

            strcpy(szAns, sets[nI].szLines[i]);
            strcat(szAns, sets[nAnsLen - nI].szLines[j]);
            if (nI == nAnsLen - nI)
            {
                dfs(nI, sets[nI].nNum - 2);
            }
            else
            {
                dfs(nI, sets[nI].nNum - 1);
            }
            if (bFind)
            {
                for (int k = nI + 1; k <= nAnsLen / 2; ++k)
                {
                    bFind = false;
                    dfs(k, sets[k].nNum);
                    if (!bFind)
                    {
                        break;
                    }
                }
                if (bFind)
                {
                    return true;
                }
            }

            strcpy(szAns, sets[nAnsLen - nI].szLines[j]);
            strcat(szAns, sets[nI].szLines[i]);
            if (nI == nAnsLen - nI)
            {
                dfs(nI, sets[nI].nNum - 2);
            }
            else
            {
                dfs(nI, sets[nI].nNum - 1);
            }
            if (bFind)
            {
                for (int k = nI + 1; k <= nAnsLen / 2; ++k)
                {
                    bFind = false;
                    dfs(k, sets[k].nNum);
                    if (!bFind)
                    {
                        break;
                    }
                }
                if (bFind)
                {
                    return true;
                }
            }

            sets[nI].bUsed[i] = false;
            sets[nAnsLen - nI].bUsed[j] = false;
        }
    }

    return false;
}

void Search()
{
    for (int i = 0; i <= nAnsLen; ++i)
    {
        if (sets[i].nNum)
        {
            Find(i);
            break;
        }
    }
}

int main()
{
    int nCases;
    
    #ifdef CSU_YX
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    #endif
    scanf("%d\n", &nCases);

    int nNum = 0;
    int nTotalLen = 0;
    while (gets(szLines[nNum]), nCases)
    {
        if (szLines[nNum][0] == '\0' && nNum != 0)
        {
            nAnsLen = nTotalLen * 2 / nNum;
            memset(szAns, 0, sizeof(szAns));
            Search();
            printf("%s\n\n", szAns);
            
            memset(sets, 0, sizeof(sets));
            memset(szLines, 0, sizeof(szLines));
            nNum = 0;
            nTotalLen = 0;
            --nCases;
        }
        else if (szLines[nNum][0] != '\0')
        {
            int nLen = strlen(szLines[nNum]);
            nTotalLen += nLen;
            strcpy(sets[nLen].szLines[sets[nLen].nNum], szLines[nNum]);
            ++sets[nLen].nNum;
            ++nNum;
        }
    }

    return 0;
}


yx 2012-03-30 18:52 发表评论
]]>生成排列的算法(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百练 - 2774:木材加工http://www.cppblog.com/csu-yx-2013/archive/2011/12/08/161713.htmlyxyxWed, 07 Dec 2011 17:43:00 GMThttp://www.cppblog.com/csu-yx-2013/archive/2011/12/08/161713.htmlhttp://www.cppblog.com/csu-yx-2013/comments/161713.htmlhttp://www.cppblog.com/csu-yx-2013/archive/2011/12/08/161713.html#Feedback0http://www.cppblog.com/csu-yx-2013/comments/commentRss/161713.htmlhttp://www.cppblog.com/csu-yx-2013/services/trackbacks/161713.htmlhttp://poj.grids.cn/practice/2774

这个题可以用二分解,虽然也有dp的解法。可能用二分解这个题不是很明显,但是确实是可以的。最大的解就是所有的棍子长/要求的棍子数,最小的解是0,直接在其中进行二分即可。这个题属于二分出最大满足条件的解的情况。这个题为什么能够二分了。我是这样想的。首先,解空间确实是有序的吧,从数字0-数字nSum/nK。其次,对于任意一个处于这个范围内的数字,只有满足和满足题目要求2种情况,那么和我们二分数字有什么区别了,我们二分一个有序数组,看里面有没有某个数字,是不是也只要判断下nMid满足是否条件是吧。所以,这个题是可以二分的。二分的条件就是解空间有序的,或者可以方便在解空间里面跳跃。而且这个题的二分还需要点技巧,因为是查找满足条件的最大解。

代码:
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define MAX (10000 + 10)
using namespace std;
int nN, nK;
int nWoods[MAX];
bool IsAnsOk(int nAns)
{
    if (nAns == 0)
    {
        return true;
    }
    else
    {
        int nTotal = 0;
        for (int i = nN - 1; i >= 0; --i)
        {
            nTotal += nWoods[i] / nAns;
            if (nTotal >= nK)
            {
                return true;
            }
        }
        return false;
    }
}
int SearchAns(int nMax)
{
    int nBeg = 0, nEnd = nMax;
    while (nBeg <= nEnd)
    {
        int nMid = (nBeg + nEnd) / 2;
        if (IsAnsOk(nMid))
        {
            nBeg = nMid + 1;
        }
        else
        {
            nEnd = nMid - 1;
        }
    }
    return nBeg - 1;
}
int main()
{
    while (scanf("%d%d", &nN, &nK) == 2)
    {
        int nSum = 0;
        for (int i = 0; i < nN; ++i)
        {
            scanf("%d", &nWoods[i]);
            nSum += nWoods[i];
        }
        sort(nWoods, nWoods + nN);
        int nMax = nSum / nK;
        printf("%d\n", SearchAns(nMax));
    }
    return 0;
}

所以,只是把==换成了IsAnsOk函数调用而已...而且由于这是查找最大解,返回值做了下变化而已...
仔细分析二分的写法(我的另一篇文章(标题是关于密码的一个解题报告)有说明),
其实写出查找最大解和最小解的二分都不是件麻烦的事情...


yx 2011-12-08 01:43 发表评论
]]>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 发表评论
]]>POJ百练 - 2804:词典http://www.cppblog.com/csu-yx-2013/archive/2011/11/16/160256.htmlyxyxWed, 16 Nov 2011 05:52:00 GMThttp://www.cppblog.com/csu-yx-2013/archive/2011/11/16/160256.htmlhttp://www.cppblog.com/csu-yx-2013/comments/160256.htmlhttp://www.cppblog.com/csu-yx-2013/archive/2011/11/16/160256.html#Feedback1http://www.cppblog.com/csu-yx-2013/comments/commentRss/160256.htmlhttp://www.cppblog.com/csu-yx-2013/services/trackbacks/160256.htmlhttp://poj.grids.cn/practice/2804/

这也是一个很简单的题目,大家一看都知道用什么方法了,当然如果是查找的话,顺序查找是不行的,
方法一,是用map,建立个map<string, string>的字典,注意不要想当然用map<char*, char*>,
那样得动态分配内存,或者还是先开个大数组存好字典,其结果还是多浪费了内存...
排序+二分也不错的,因为数据量确实很大,而且题目也建议用c的io输入,所以这样再建立map<string, string>
中间还得转换一下...
总之做这个题还是很顺利的,就wa了一次,原因是2分写错了,我也很久没在oj上写2分了...

代码如下:
#include <stdio.h>
#include <string.h>
#include <algorithm>

#define MAX_WORD_LEN 11
#define MAX_DICTION_ITEM (100000 + 10)

using std::sort;

struct Dictionary
{
    char szWord[MAX_WORD_LEN];
    char szEnglish[MAX_WORD_LEN];
};

Dictionary diction[MAX_DICTION_ITEM];

bool CmpDictionItem(Dictionary one, Dictionary two)
{
    return strcmp(one.szWord, two.szWord) < 0;
}

int FindEnglish(char* pszWord, int nItemNum)
{
    int nBeg = 0, nEnd = nItemNum - 1;
    int nCmp = 0;
    
    while (nBeg <= nEnd)
    {
        int nMid = (nBeg + nEnd) / 2;
        nCmp = strcmp(pszWord, diction[nMid].szWord);
        if (nCmp == 0)
        {
            return nMid;
        }
        else if (nCmp < 0)
        {
            nEnd = nMid - 1;
        }
        else
        {
            nBeg = nMid + 1;
        }
    }
    
    return -1;
}

int main()
{
    char szStr[30];
    char szWord[MAX_WORD_LEN];
    int nCount = 0;
    int nAnsItem = 0;
    
    while (fgets(szStr, 29, stdin), szStr[0] != '\n')
    {
        sscanf(szStr, "%s%s", diction[nCount].szEnglish, diction[nCount].szWord);
        ++nCount;
    }
    sort(diction, diction + nCount, CmpDictionItem);
    while (scanf("%s", szWord) == 1)
    {
        if ((nAnsItem = FindEnglish(szWord, nCount)) != -1)
        {
            printf("%s\n", diction[nAnsItem].szEnglish);
        }
        else
        {
            printf("eh\n"); 
        }
    }
    
    return 0;
}

其实我的主要目的是为了指出二分的写法,大家看我的FindEnglish函数,传递的是数组的地址和数组的长度,
然后我写函数体的时候用的是[]的形式,就是下确界,上确界,这样最重要的是需要考虑循环的条件是<还是
<=,其实这也很好判断,因为上界和下界都能够取到,所以=是成立的...而且修改right的时候,必须将right = mid - 1,
原因也是因为这是上确界,
但是如果是上不确界了,那么等号就必须去掉,而且right也只能修改为mid,因为mid-1就是确界了,而mid才是上不确界...
想到这个程度的话,以后写只有唯一解二分就应该不会出错了...但是写查找满足条件的最大或者最小解的二分还需要其它技巧...


yx 2011-11-16 13:52 发表评论
]]>