C++博客-yx-随笔分类-数据结构

poj 3264 Balanced Lineup St算法建立Rmq

yx — Thu, 25 Oct 2012 11:29:00 GMT

ST算法可以说就是个二维的动态规划，黑书上有解释。

#include
#include <string.h>
#include
#include
using namespace std;

const int MAX_I = 50010;
const int MAX_J = 20;

int nMax[MAX_I][MAX_J];
int nMin[MAX_I][MAX_J];
int nArr[MAX_I];
int nN, nQ;

void InitRmq(int nN)
{
    for (int i = 1; i <= nN; ++i)
    {
        nMax[i][0] = nMin[i][0] = nArr[i];
    }

    for (int j = 1; (1 << j) <= nN; ++j)
    {
        for (int i = 1; i + (1 << j) - 1 <= nN; ++i)
        {
            nMax[i][j] = max(nMax[i][j - 1],
                             nMax[i + (1 << (j - 1))][j - 1]);
            nMin[i][j] = min(nMin[i][j - 1],
                             nMin[i + (1 << (j - 1))][j - 1]);
        }
    }
}

int Query(int nA, int nB)
{
    int k = (int)(log(1.0 * nB - nA + 1) / log(2.0));
    int nBig = max(nMax[nA][k], nMax[nB - (1 << k) + 1][k]);
    int nSml = min(nMin[nA][k], nMin[nB - (1 << k) + 1][k]);
    return nBig - nSml;
}

int main()
{
    while (scanf("%d%d", &nN, &nQ) == 2)
    {
        for (int i = 1; i <= nN; ++i)
        {
            scanf("%d", &nArr[i]);
        }
        InitRmq(nN);
        for (int i = 0; i < nQ; ++i)
        {
            int nA, nB;
            scanf("%d%d", &nA, &nB);
            printf("%d\n", Query(nA, nB));
        }
    }

    return 0;
}

yx 2012-10-25 19:29 发表评论

poj 3764 The xor-longest Path 字典树 + Xor

yx — Fri, 12 Oct 2012 12:12:00 GMT

这题意思很简单。求一棵树里面的一条路径，使得其异或权(就是将路径里面所有边的权值异
或起来)最大。
这个题有两步。第一步是假定根为节点0，求出根到其它节点的异或距离，保存在数组xor里面，
这个dfs一下即可。然后，用xor[i]^xor[j]就能代表节点i到节点j的路径。这个结论可以这么看。
如果，i和j之间的路径经过根节点，那么上面的结论肯定是正确的。如果，该路径不经过根，那么
xor[i]和xor[j]必定保护从根到某个节点的相同的一段子路径，根据异或的性质，这段子路径会
被消掉，所以这个结论也是这确的。。。
第二步就是枚举，xor[i]^xor[j]使得结果最大了。如果直接暴力，平方的算法肯定会超时的。
由于每个值可以表示成2进制，如果把其它xor值都保存在字典树里面，用当前的xor[i]去字典树
里面，一遍就可以找到异或最大值。
另外，由于树的点数太多，只能用邻接表，用vector模拟邻接表果断超时了。。。
改成静态链表才过。。。

代码如下：

#include
#include <string.h>
#include
#include
using namespace std;

const int MAX = 100010;
int nXor[MAX];
bool bVis[MAX];
int nFirst[MAX];
struct Edge
{
    int nE;
    int nW;
    int nNext;
};
Edge egs[MAX * 2];

struct Node
{
    Node* pSons[2];
};
Node nodes[MAX * 32];
Node* pRoot = &nodes[0];
int nNew;

void GetBCode(int nL, int* nBCode, int& nLen)
{
    nLen = 0;
    while (nLen <= 30)
    {
        nBCode[nLen++] = nL % 2;
        nL >>= 1;
    }
    reverse(nBCode, nBCode + nLen);
}

void Insert(int nL)
{
    int nLen = 0;
    int i = 0;
    int nBCode[32];

    GetBCode(nL, nBCode, nLen);
    Node* pNode = pRoot;

    while (i < nLen)
    {
        if (pNode->pSons[nBCode[i]])
        {
            pNode = pNode->pSons[nBCode[i]];
        }
        else
        {
            memset(nodes + nNew, 0, sizeof(nodes[nNew]));
            pNode->pSons[nBCode[i]] = nodes + nNew;
            pNode = nodes + nNew;
            ++nNew;
        }
        ++i;
    }
}

int FindMax(int nL)
{
    int nLen = 0;
    int nAns = 0;
    int i = 0;
    int nBCode[32];
    Node* pNode = pRoot;

    GetBCode(nL, nBCode, nLen);
    while (i < nLen)
    {
        int nBest = (nBCode[i] == 0 ? 1 : 0);
        int nBad = (nBCode[i] == 0 ? 0 : 1);
        if (pNode->pSons[nBest])
        {
            nAns = 2 * nAns + nBest;
            pNode = pNode->pSons[nBest];
        }
        else if (pNode->pSons[nBad])
        {
            nAns = 2 * nAns + nBad;
            pNode = pNode->pSons[nBad];
        }
        else break;
        ++i;
    }

    return nAns ^ nL;
}

void Dfs(int nV, int nL)
{
    nXor[nV] = nL;
    bVis[nV] = true;
    for (int e = nFirst[nV]; e != -1; e = egs[e].nNext)
    {
        if (!bVis[egs[e].nE])
        {
            Dfs(egs[e].nE, nL ^ egs[e].nW);
        }
    }
}

int main()
{
    int nN;
    int nU, nV, nW;

    while (scanf("%d", &nN) == 1)
    {
        for (int i = 0; i < nN; ++i) nFirst[i] = -1;
        for (int i = 1, j = 0; i < nN; ++i)
        {
            scanf("%d%d%d", &nU, &nV, &nW);
            egs[j].nE = nV;
            egs[j].nW = nW;
            egs[j].nNext = nFirst[nU];
            nFirst[nU] = j++;
            egs[j].nE = nU;
            egs[j].nW = nW;
            egs[j].nNext = nFirst[nV];
            nFirst[nV] = j++;
        }

        memset(bVis, false, sizeof(bool) * nN);
        Dfs(0, 0);

        memset(&nodes[0], 0, sizeof(Node));
        nNew = 1;
        int nAns = 0;

        for (int i = 0; i < nN; ++i)
        {
            nAns = max(nAns, FindMax(nXor[i]));
            Insert(nXor[i]);
        }
        printf("%d\n", nAns);
    }

    return 0;
}

yx 2012-10-12 20:12 发表评论

poj 1182 食物链并查集

yx — Wed, 10 Oct 2012 12:51:00 GMT

这是并查集最后一题，据说也是最经典的一题。经常前面几题的训练，这题的思路很快
就能想出来了。只需要对每个节点附加一个信息表示离根节点的距离，并且距离是模3循环的。
注意合并时候保持距离变化的正确性。而且合并有2种情况，距离相同合并和距离不同合并。
分别对应于题目描述中的1和2操作。
关键还是FindSet里面对距离nDis数组里面的修改，前面一直写错这个，wa了好几次，还是
看队友代码才一眼发现我又把这里写错了。。。当前距离的更新还是等于当前距离加上前一个
节点的距离再模3，类似于前面几题的更新方法。
这种将有关系的节点放在一个并查集里面，再给每个节点附加其它信息描述其它关系的做法，
确实比较有效。。。并查集是应用于不相交集合的数据结构，看来某个时候却有妙用啊。。。

代码如下：

#include
#include <string.h>
#include
using namespace std;

const int MAX = 50010;
int nN, nK;
int nSets[MAX];
int nDis[MAX];

void MakeSets(int nN)
{
    for (int i = 1; i <= nN; ++i)
    {
        nSets[i] = i;
        nDis[i] = 0;
    }
}

int FindSet(int nI)
{
    if (nSets[nI] != nI)
    {
        int nPre = nSets[nI];
        nSets[nI] = FindSet(nSets[nI]);
        nDis[nI] = (nDis[nPre] + nDis[nI]) % 3;
    }
    return nSets[nI];
}

int main()
{
    int nAns = 0;
    int nOper, nX, nY;

    scanf("%d%d", &nN, &nK);
    MakeSets(nN);
    while (nK--)
    {
        scanf("%d%d%d", &nOper, &nX, &nY);
        if (nX > nN || nY > nN || nOper == 2 && nX == nY)
        {
            ++nAns;
        }
        else
        {
            if (nOper == 1)
            {
                int nA = FindSet(nX);
                int nB = FindSet(nY);
                if (nA == nB)
                {
                    if (nDis[nX] != nDis[nY])
                    {
                        ++nAns;
                    }
                }
                else
                {
                    nSets[nB] = nA;
                    nDis[nB] = (nDis[nX] - nDis[nY] + 3) % 3;
                }
            }
            else
            {
                int nA = FindSet(nX);
                int nB = FindSet(nY);
                if (nA == nB)
                {
                    if ((nDis[nX] + 1) % 3 != nDis[nY])
                    {
                        ++nAns;
                    }
                }
                else
                {
                    nSets[nB] = nA;
                    nDis[nB] = (nDis[nX] + 1 - nDis[nY] + 3) % 3;
                }
            }
        }
    }
    printf("%d\n", nAns);

    return 0;
}

yx 2012-10-10 20:51 发表评论

poj 1988 Cube Stacking 并查集

yx — Wed, 10 Oct 2012 04:15:00 GMT

也是个题意比较奇葩的题目。有2个操作，1个是把一个元素所在的栈，放到另外1个元素所在
的栈上面。另外一个操作是统计某个元素下面有多少个元素(当然是在同一个栈中）。
貌似，需要记录每个元素下面的元素是什么了，既然要记录这个就不能用并查集的路径压缩了。
不压缩路径的话，肯定会超时的。怎么办了。。。
其实，可以这么考虑，以每个栈的栈底元素作为并查集的代表元素。压缩路径后，每个元素或者
是根元素或者其父亲元素就是根元素。所以，另外对每个节点附加个信息代表该节点的高度，栈底
元素高度为0。再附加个信息代表每个并查集元素总数目，这样就可以在合并集合时候修改信息，
并且压缩路径也能保证答案正确。。。

代码如下：

#include
#include
#include <string.h>
#include
using namespace std;

const int MAX = 30010;
int nSets[MAX];
int nNum[MAX];
int nRank[MAX];

void MakeSets(int nN)
{
    for (int i = 0; i < nN; ++i)
    {
        nSets[i] = i;
        nNum[i] = 1;
        nRank[i] = 0;
    }
}

int FindSet(int nI)
{
    if (nSets[nI] != nI)
    {
        int nPre = nSets[nI];
        nSets[nI] = FindSet(nSets[nI]);
        nRank[nI] += nRank[nPre];
    }

    return nSets[nI];
}

void Move(int nX, int nY)
{
    int nA = FindSet(nX);
    int nB = FindSet(nY);
    //printf("nA:%d,nB:%d\n", nA, nB);
    if (nA != nB)
    {
        nSets[nA] = nB;
        nRank[nA] += nNum[nB];
        nNum[nB] += nNum[nA];
    }
}

int main()
{
    int nP;
    char szOper[10];
    int nX, nY;

    scanf("%d", &nP);
    MakeSets(MAX);
    while (nP--)
    {
        scanf("%s", szOper);
        if (szOper[0] == 'M')
        {
            scanf("%d%d", &nX, &nY);
            Move(nX, nY);
        }
        else
        {
            scanf("%d", &nX);
            FindSet(nX);
            printf("%d\n", nRank[nX]);
        }
    }

    return 0;
}

yx 2012-10-10 12:15 发表评论

poj 1984 Navigation Nightmare 并查集

yx — Tue, 09 Oct 2012 13:25:00 GMT

并查集应用的变形。题目意思是一个图中，只有上下左右四个方向的边。给出这样的一些边，
求任意指定的2个节点之间的距离。
有可能当前给出的信息，没有涉及到要求的2个节点，或者只涉及到了1个节点，那么肯定
无法确定它们的距离。或者根据已经给出的边只知道这2个节点在不同的联通分量里面，那么其
距离也是无法确定的，根据题目要求，输出-1。
问题是如果能够确定它们在一个联通分量里面，如何确定它们的距离了。
这个题的关键在于，只有上下左右四个方向的边，假设每个节点都有一个坐标的话，那么它们
相对于代表该联通分量节点的坐标肯定是固定的，那么就不需要考虑图里面有环之类的情况了。
这样就可以很方便的应用并查集来解了。
利用并查集，给每个节点附加其它信息，即相对于代表该并查集的节点的坐标（x，y）。
在FindSet里面求出坐标，在UnionSet里面修改合并后新加入的另外一个集合的根节点的坐标即可。
代码如下：

#include
#include <string.h>
#include
#include
using namespace std;

const int MAX_N = 40010;
int nN, nM;
int nSets[MAX_N];
int nX[MAX_N];
int nY[MAX_N];
char szInput[MAX_N][100];

void MakeSets(int nNum)
{
    for (int i = 0; i < nNum; ++i)
    {
        nSets[i] = i;
        nX[i] = nY[i] = 0;
    }
}

int FindSets(int nI)
{
    if (nSets[nI] != nI)
    {
        int nPre = nSets[nI];
        nSets[nI] = FindSets(nSets[nI]);
        nX[nI] += nX[nPre];
        nY[nI] += nY[nPre];
    }
    return nSets[nI];
}

void UnionSets(int nBeg, int nEnd, int dx, int dy)
{
    int nA = FindSets(nBeg);
    int nB = FindSets(nEnd);
    if (nA != nB)
    {
        nSets[nB] = nA;//把集合B合并到集合A中
        nX[nB] = nX[nBeg] + dx - nX[nEnd];//因为方向逆过来了,所以是减去
        nY[nB] = nY[nBeg] + dy - nY[nEnd];
    }
}

int main()
{
    int nBeg, nEnd, nL;
    char szDir[10];

    while (scanf("%d%d%*c", &nN, &nM) == 2)
    {
        MakeSets(nN);
        for (int i = 0; i < nM; ++i)
        {
            fgets(szInput[i], 100, stdin);
        }
        int nK;
        int nF1, nF2, nI;
        scanf("%d", &nK);
        int nCur = 0;
        while (nK--)
        {
            scanf("%d%d%d", &nF1, &nF2, &nI);
            for (int i = nCur; i < nI; ++i)
            {
                sscanf(szInput[i], "%d%d%d%s", &nBeg,
                       &nEnd, &nL, szDir);
                int dx = 0, dy = 0;
                switch (szDir[0])
                {
                    case 'N': dy += nL; break;
                    case 'S': dy -= nL; break;
                    case 'E': dx += nL; break;
                    case 'W': dx -= nL; break;
                }
                UnionSets(nBeg, nEnd, dx, dy);
            }
            nCur = nI;

            if (FindSets(nF1) != FindSets(nF2))
            {
                printf("-1\n");
            }
            else
            {
                printf("%d\n", abs(nX[nF1] - nX[nF2])
                        + abs(nY[nF1] - nY[nF2]));
            }
        }
    }

    return 0;
}

yx 2012-10-09 21:25 发表评论

poj 1703 Find them, Catch them 并查集

yx — Mon, 08 Oct 2012 14:33:00 GMT

并查集应用的变形。
给出的是2个节点是敌对关系的信息，最后询问任意2个节点的关系。根据这些信息，
节点之间可能是敌对的，也可能不是的（因为敌人的敌人就是朋友），也可能给出的
信息根本描述不了它们的关系。
看起来跟原始的并查集应用差远了。。。
有个比较直接的做法，那么就是把不在一个集合的节点直接用并查集合并在一起。这样的话，
如果询问的2个节点在同一个并查集里面，那么它们之间的关系是确定的，否则无法确定它们的
关系。
现在还有一个问题是，在同一个并查集里面的2个节点是敌对关系还是朋友关系。。。
可以给每个节点另外附加个信息，记录其距离并查集根节点的距离。如果，询问的2个节点距离
其根节点的距离都是奇数或者都是偶数，那么这2个节点是朋友关系，否则是敌对关系。。。

代码如下：

#include
#include <string.h>
#include
using namespace std;

const int MAX_N = 100010;
int nSets[MAX_N];
int nDis[MAX_N];

int nN, nM;

void MakeSets(int nNum)
{
    for (int i = 0; i < nNum; ++i)
    {
        nSets[i] = i;
        nDis[i] = 0;
    }
}

int FindSet(int nI)
{
    if (nSets[nI] != nI)
    {
        int nPre = nSets[nI];
        nSets[nI] = FindSet(nSets[nI]);
        nDis[nI] = (nDis[nI] + nDis[nPre]) % 2;
    }
    return nSets[nI];
}

void UnionSet(int nI, int nJ)
{
    int nA = FindSet(nI);
    int nB = FindSet(nJ);
    if (nA != nB)
    {
        nSets[nA] = nB;
        nDis[nA] = (nDis[nI] + nDis[nJ] + 1) % 2;
    }
}

int main()
{
    int nT;

    scanf("%d", &nT);
    while (nT--)
    {
        scanf("%d%d", &nN, &nM);
        MakeSets(nN);
        char szOper[10];
        int nA, nB;
        while (nM--)
        {
            scanf("%s%d%d", szOper, &nA, &nB);
            if (szOper[0] == 'D')
            {
                UnionSet(nA, nB);
            }
            else
            {
                int nX = FindSet(nA);
                int nY = FindSet(nB);
                if (nX == nY)
                {
                    if (nDis[nA] == nDis[nB])
                    {
                        printf("In the same gang.\n");
                    }
                    else
                    {
                        printf("In different gangs.\n");
                    }
                }
                else
                {
                    printf("Not sure yet.\n");
                }
            }
        }
    }

    return 0;
}

yx 2012-10-08 22:33 发表评论

poj 3468 A Simple Problem with Integers 线段树成段延迟更新

yx — Sun, 16 Sep 2012 12:42:00 GMT

用线段树成段更新不能立即全部更新，必须搞延迟操作。其实，就是针对每个节点，另外搞一个域表示延迟
更新的数目。然后，在更新操作和查找操作的时候都把父亲节点的延迟域往2个儿子走。
这个题是要成段增加值，所以在写PushDown函数的时候要注意，只能给儿子节点加上父亲节点压过来的值
乘以儿子区间的长度。这题貌似用树状数组也可以做，不过解法肯定意思不是那么直白的。不过速度肯定会快。
树状数组解法：http://kenby.iteye.com/blog/962159
线段树网上流行的解法都是开最多节点数目4倍的数组。以位置1作为根，每个位置其实代表的是一个区间。
某人位置1代表1-N或者0-(N-1)区间，具体看题目了。那么2就代表区间1-(1+N)/2，3就代表区间(1+N)/2+1 - N了。
至于lazy标记还是搞个大数组，意义和线段树数组一样，搞清楚之后写起来都比较简单，最重要的是变形来
解决一些要求奇怪的题目。

#include

#include <string.h>
#include
using namespace std;
typedef long long INT;

const INT MAX_N = 100010;
const INT INF = 0x7ffffffffffffffLL;
INT nTree[MAX_N << 2];
INT nAdd[MAX_N << 2];
INT nN, nQ;

void PushUp(INT nRt)
{
    nTree[nRt] = nTree[nRt << 1] + nTree[nRt << 1 | 1];
}

void BuildTree(INT nL, INT nR, INT nRt)
{
    nAdd[nRt] = 0;
    if (nL == nR)
    {
        scanf("%I64d", &nTree[nRt]);
        return;
    }

    INT nMid = (nL + nR) >> 1;
    BuildTree(nL, nMid, nRt << 1);
    BuildTree(nMid + 1, nR, nRt << 1 | 1);
    PushUp(nRt);
}

void PushDown(INT nL, INT nR, INT nRt)
{
    INT nMid = (nL + nR) >> 1;
    INT nLs = nRt << 1;
    INT nRs = nLs | 1;

    if (nAdd[nRt])
    {
        nAdd[nLs] += nAdd[nRt];
        nAdd[nRs] += nAdd[nRt];
        nTree[nLs] += (nMid - nL + 1) * nAdd[nRt];
        nTree[nRs] += (nR - nMid) * nAdd[nRt];
        nAdd[nRt] = 0;
    }
}

void Update(INT nL, INT nR, INT nRt, INT nX, INT nY, INT nV)
{
    if (nL >= nX && nR <= nY)
    {
        nTree[nRt] += nV * (nR - nL + 1);
        nAdd[nRt] += nV;
        return;
    }

    PushDown(nL, nR, nRt);
    INT nMid = (nL + nR) >> 1;
    if (nX <= nMid) Update(nL, nMid, nRt << 1, nX, nY, nV);
    if (nY > nMid) Update(nMid + 1, nR, nRt << 1 | 1, nX, nY, nV);
    PushUp(nRt);
}

INT Query(INT nL, INT nR, INT nRt, INT nX, INT nY)
{
    if (nL >= nX && nR <= nY)
    {
        return nTree[nRt];
    }
    PushDown(nL, nR, nRt);
    INT nAns = 0;
    INT nMid = (nL + nR) >> 1;
    if (nX <= nMid) nAns += Query(nL, nMid, nRt << 1, nX, nY);
    if (nY > nMid) nAns += Query(nMid + 1, nR, nRt << 1 | 1, nX, nY);
    return nAns;
}

int main()
{
    INT nTemp;
    while (scanf("%I64d%I64d", &nN, &nQ) == 2)
    {
        BuildTree(1, nN, 1);

        while (nQ--)
        {
            char szCmd[10];
            INT nX, nY, nV;
            scanf("%s", szCmd);
            if (szCmd[0] == 'Q')
            {
                scanf("%I64d%I64d", &nX, &nY);
                printf("%I64d\n", Query(1, nN, 1, nX, nY));
            }
            else
            {
                scanf("%I64d%I64d%I64d", &nX, &nY, &nV);
                Update(1, nN, 1, nX, nY, nV);
            }
        }
    }

    return 0;
}

yx 2012-09-16 20:42 发表评论

poj 2886 Who Gets the Most Candies? 约瑟夫环和反素数

yx — Fri, 14 Sep 2012 12:53:00 GMT

直接模拟约瑟夫环是N^2，况且这题每次移动的距离和方向都是不确定的，只能模拟，如果加快查找和移动的话，
可以提高速度，果断用线段树维护当前位置前面有多少个人。
至于反素数指的是求一个小于等于N的数字，使得其因子个数在1-N中是最大的。这个利用一个必要条件暴力搜索即可。

其实就是利用下面这2个性质搜索的。
性质一:一个反素数的质因子必然是从2开始连续的质数。性质二:p=2^t1*3^t2*5^t3*7^t4.....必然t1>=t2>=t3>=....。

代码如下：

#include
#include <string.h>
#include
#include
using namespace std;

int nPrime[16] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53};
int nAns;
int nCN;
const int MAX_N = 500010;
//nPow不会超过20
void InitBest(int nCur, int nI, int nMax, int nN, int nNum)
{
    if (nCur > nN) return;
    if (nNum > nCN){nAns = nCur;nCN = nNum;}
    if (nNum == nCN){nAns = min(nAns, nCur);}
    for (int i = 1; i <= nMax; ++i)
    {
        nCur *= nPrime[nI];
        if (nCur > nN)return;//不加这句优化会超时
        if (nI < 15)
        InitBest(nCur, nI + 1, i, nN, nNum * (i + 1));
    }
}

char szNames[MAX_N][10];
int nValue[MAX_N];
int nTree[MAX_N << 2];
void PushUp(int nRt)
{
    nTree[nRt] = nTree[nRt << 1] + nTree[nRt << 1 | 1];
}

void BuildTree(int nL, int nR, int nRt, int nV)
{
    if (nL == nR)
    {
        nTree[nRt] = nV;
        return;
    }
    int nMid = (nL + nR) >> 1;
    BuildTree(nL, nMid, nRt << 1, nV);
    BuildTree(nMid + 1, nR, nRt << 1 | 1, nV);
    PushUp(nRt);
}

void Add(int nL, int nR, int nRt, int nP, int nV)
{
    if (nL == nR)
    {
        nTree[nRt] += nV;
    }
    else
    {
        int nMid = (nL + nR) >> 1;
        if (nP <= nMid)Add(nL, nMid, nRt << 1, nP, nV);
        else Add(nMid + 1, nR, nRt << 1 | 1, nP, nV);
        PushUp(nRt);
    }
}

int Query(int nL, int nR, int nRt, int nSum)
{
    if (nL == nR)
    {
        return nL;
    }
    int nMid = (nL + nR) >> 1;
    int nLs = nRt << 1;
    int nRs = nLs | 1;
    if (nTree[nLs] >= nSum) return Query(nL, nMid, nLs, nSum);
    else return Query(nMid + 1, nR, nRs, nSum - nTree[nLs]);
}

int main()
{
    //InitBest(1, 0, 15);
    int nN, nK;

    while (scanf("%d%d", &nN, &nK) == 2)
    {
        nK--;
        nAns = 2;
        nCN = 0;
        InitBest(1, 0, 20, nN, 1);
        //printf("ans:%d cn:%d\n", nAns, nCN);
        for (int i = 0; i < nN; ++i)
        {
            scanf("%s%d", szNames[i], &nValue[i]);
        }

        BuildTree(0, nN - 1, 1, 1);
        int nTotal = nN;
        int nPos;
        for (int i = 0; i < nAns; ++i)
        {
            nPos = Query(0, nN - 1, 1, nK + 1);
            //printf("nK:%d %s %d\n", nK, szNames[nPos], nValue[nPos]);
            nTotal--;
            Add(0, nN - 1, 1, nPos, -1);
            if (!nTotal)break;
            if (nValue[nPos] >= 0)
            {
                nK = (nK - 1 + nValue[nPos] + nTotal) % nTotal;
            }
            else
            {
                nK = ((nK + nValue[nPos]) % nTotal + nTotal) % nTotal;
            }
        }
        printf("%s %d\n", szNames[nPos], nCN);
    }

    return 0;
}

yx 2012-09-14 20:53 发表评论

hdu 2492 Ping pong 树状数组

yx — Wed, 12 Sep 2012 13:11:00 GMT

此题是求一个数字序列中，长度为3的子序列(a,b,c)，且满足条件a<=b<=c或者c<=b<=a的子序列的个数。
明显枚举每个b，求每个b左边的a的个数和右边c的个数，以及左边c的个数和右边a的个数，然后累加左右乘积求和即可。
刚开始只求了满足条件a<=b<=c的部分，而且忘记用64位了。wa了几次。求左边a的个数其实就是求小于等于b的数字
的个数，这个刚好可以用树状数组或者线段树求。具体见代码。

代码如下：

#include

#include <string.h>
#include
using namespace std;
typedef long long INT;
const INT MAX_N =  100010;
const INT N = 20010;
INT nN;
INT nNum[N];
INT nTree[MAX_N + 10];
INT nLeft[2][N], nRight[2][N];

INT LowBit(INT nI)
{
    return nI & (-nI);
}

void Add(INT nI, INT nAdd)
{
    while (nI <= MAX_N)
    {
        nTree[nI] += nAdd;
        nI += LowBit(nI);
    }
}

INT Query(INT nPos)
{
    INT nAns = 0;
    while (nPos > 0)
    {
        nAns += nTree[nPos];
        nPos -= LowBit(nPos);
    }
    return nAns;
}

int main()
{
    INT nT;

    scanf("%I64d", &nT);
    while (nT--)
    {
        scanf("%I64d", &nN);
        memset(nTree, 0, sizeof(nTree));
        for (INT i = 1; i <= nN; ++i)
        {
            scanf("%I64d", &nNum[i]);
            nLeft[0][i] = Query(nNum[i]);
            nLeft[1][i] = Query(MAX_N) - Query(nNum[i] - 1);
            Add(nNum[i], 1);
        }
        memset(nTree, 0, sizeof(nTree));
        for (INT i = nN; i >= 1; --i)
        {
            nRight[0][i] = Query(MAX_N) - Query(nNum[i] - 1);
            nRight[1][i] = Query(nNum[i]);
            Add(nNum[i], 1);
        }
        INT nAns = 0;
        for (INT i = 1; i <= nN; ++i)
        {
            nAns += nLeft[0][i] * nRight[0][i] + nLeft[1][i] * nRight[1][i];
        }
        printf("%I64d\n", nAns);
    }

    return 0;
}

yx 2012-09-12 21:11 发表评论

hdu 3584 Cube 三维树状数组

yx — Mon, 10 Sep 2012 07:43:00 GMT

这个题意思是翻转一个01立方体。翻转多次后再查询某个点的值。
还是利用上一篇文章的思想，把翻转操作转换为单点更新操作。把查询操作转换为利用树状数组查询和的方式。
这样每次操作的复杂度都是logN的3次。而直接翻转立方体的复杂度是N的3次。
这个题最麻烦的地方是空间想象能力。因为要翻转8个点才能完成一次立方体翻转。比如，翻转(x,y,z)相当于
以该点作为左上角做一个无限立方体，把该立方体翻转。这样就会翻转多余的部分，那么需要把多翻转的部分翻转
回来。最后的思考结果发现，只要对每个顶点翻转一次即可。至于为什么这样，自己去计算重复翻转的部分就会明白
了。刚好确实是把每个点翻转了一次。

代码如下：

#include

#include <string.h>
#include
using namespace std;

const int MAX_N = 110;
int nSum[MAX_N + 10][MAX_N + 10][MAX_N + 10];
int nN, nM;

int LowBit(int nPos)
{
    return nPos & (-nPos);
}

void Add(int nX, int nY, int nZ)
{
    for (int i = nX; i <= nN; i += LowBit(i))
    {
        for (int j = nY; j <= nN; j += LowBit(j))
        {
            for (int k = nZ; k <= nN; k += LowBit(k))
            {
                nSum[i][j][k]++;
            }
        }
    }
}

int Query(int nX, int nY, int nZ)
{
    int nAns = 0;

    for (int i = nX; i > 0; i -= LowBit(i))
    {
        for (int j = nY; j > 0; j -= LowBit(j))
        {
            for (int k = nZ; k > 0; k -= LowBit(k))
            {
                nAns += nSum[i][j][k];
            }
        }
    }
    return nAns;
}

int main()
{
    int nCmd;
    int nX, nY, nZ;
    int nX1, nY1, nZ1;
    int nX2, nY2, nZ2;

    while (scanf("%d%d", &nN, &nM) == 2)
    {
        memset(nSum, 0, sizeof(nSum));
        while (nM--)
        {
            scanf("%d", &nCmd);
            if (nCmd == 0)
            {
                scanf("%d%d%d", &nX, &nY, &nZ);
                printf("%d\n", Query(nX, nY, nZ) % 2);
            }
            else
            {
                scanf("%d%d%d%d%d%d", &nX1, &nY1, &nZ1, &nX2, &nY2, &nZ2);
                if (nX1 > nX2)swap(nX1, nX2);
                if (nY1 > nY2)swap(nY1, nY2);
                if (nZ1 > nZ2)swap(nZ1, nZ2);
                Add(nX1, nY1, nZ1);

                Add(nX2 + 1, nY1, nZ1);
                Add(nX1, nY2 + 1, nZ1);
                Add(nX1, nY1, nZ2 + 1);

                Add(nX1, nY2 + 1, nZ2 + 1);
                Add(nX2 + 1, nY1, nZ2 + 1);
                Add(nX2 + 1, nY2 + 1, nZ1);

                Add(nX2 + 1, nY2 + 1, nZ2 + 1);
            }
        }
    }

    return 0;
}

yx 2012-09-10 15:43 发表评论

hdu 1556 Color the ball 树状数组

yx — Thu, 06 Sep 2012 12:51:00 GMT

这个题的意思是给定一个长为N的区间。不断的给某个子区间[A,B]中的每个点涂一次色。最后问每个点的涂色次数。
这个题貌似可以扩展到多维的情况，但是多维的情况下必须用树状数组求和以加快速度，一维的情况直接求和即可。
假如，第一次涂色是对区间[A,B]涂色一次，可以让nNum[nA]++,nNum[nB+1]--即可。因为这样对于区间[0,nA-1]的任意值i有
都要nNum[1]+nNum[2]+...+nNum[i] = 0。而对于区间[nA,nB]的任意值i有nNum[1]+nNum[2]+...+nNum[i] = 0。
对于区间[nB+1, nN]的任意值i有nNum[1]+nNum[2]+...+nNum[i] = 0。
那么重复多次了。如果上述求和nNum[1]+nNum[2]+...+nNum[i] 刚好代表每个结点i的涂色次数，那么这个题就可解了。
用例子验证一下，发现肯定是这样的。证明略了。
至于树状数组网上一大堆资料。树状数组模板单一，敲代码太方便了。

代码如下：

#include

#include <string.h>
#include
using namespace std;

int nNum[100000 + 10];
int nN;
int LowBit(int nI)
{
    return nI & (-nI);
}

void Add(int nI, int nAdd)
{
    while (nI <= nN)
    {
        nNum[nI] += nAdd;
        nI += LowBit(nI);
    }
}

int GetSum(int nI)
{
    int nAns = 0;

    while (nI > 0)
    {
        nAns += nNum[nI];
        nI -= LowBit(nI);
    }
    return nAns;
}

int main()
{
    int nA, nB;

    while (scanf("%d", &nN), nN)
    {
        memset(nNum, 0, sizeof(nNum));

        for (int i = 1; i <= nN; ++i)
        {
            scanf("%d%d", &nA, &nB);
            Add(nA, 1);
            Add(nB + 1, -1);
        }
        for (int i = 1; i <= nN; ++i)
        {
            printf("%d%s", GetSum(i), i == nN ? "\n" : " ");
        }
    }

    return 0;
}

yx 2012-09-06 20:51 发表评论

poj 2823 Sliding Window 单调队列

yx — Sun, 02 Sep 2012 06:25:00 GMT

这道题的意思是给定一个长N的整数序列，用一个大小为K的窗口从头开始覆盖，问第1-第N-K次窗口里面最大的数字和最小的数字。
刚开始还以为优先级队列可以做，发现无法删除最前面的元素。估计用线段树这个题也是可以解得。用这个题学了下单调队列。

单调队列正如其名，是一个从小到大排序的队列，而且能够保证所有的元素入队列一次出队列一次，所以平摊到每个元素的复杂度
就是O(1)。
对于这个题单调队列的使用。以序列1 3 -1 -3 5 3 6 7举例。
1）元素类型：一个结构体，包含数字大小和位置，比如(1，1），（3，2）。
2）插入操作：从队尾开始查找，把队尾小于待插入元素的元素全部删除，再加入待插入的元素。这个操作最坏的
情况下是O(n)，但是我们采用聚集分析的方法，知道每个元素最多删除一次，那么N个元素删除N次，平摊到每一次
操作的复杂度就是O(1)了。
3）删除队首元素：比如本文给的那个题，窗口一直往后移动，每一次移动都会删除一个元素，所以很可能队首会是要
删除的元素，那么每次移动窗口的元素要进行一次检查，如果队首元素失效的话，就删掉队首元素。

代码的实现，我是包装deque实现了一个模版类。速度很不好，居然跑了11s多才过，幸亏给了12s的时间，看status又500多ms
就过了的。估计数组实现会快很多。

代码如下：

#include
#include
#include
using namespace std;
#define MAX_N (1000000 + 100)
int nNum[MAX_N];
int nN, nK;

struct Small
{
    int nValue;
    int nIndex;
    Small(int nV, int index):nValue(nV), nIndex(index) {}
    bool operator < (const Small& a) const
    {
        return nValue < a.nValue;
    }
};

struct Big
{
    int nValue;
    int nIndex;
    Big(int nV, int index):nValue(nV), nIndex(index) {}
    bool operator < (const Big& a) const
    {
        return nValue > a.nValue;
    }
};

//单调队列
template  class Monoque
{
    deque dn;

public:
    void Insert(T node)
    {
        int nPos = dn.size() - 1;
        while (nPos >=0 && node < dn[nPos])
        {
            --nPos;
            dn.pop_back();
        }
        dn.push_back(node);
    }

    int Top()
    {
        return dn.front().nValue;
    }

    void Del(int nBeg, int nEnd)
    {
        if (dn.size() > 0)
        {
            if (dn.front().nIndex < nBeg || dn.front().nIndex > nEnd)
            {
                dn.pop_front();
            }
        }
    }
};

int main()
{
    while (scanf("%d%d", &nN, &nK) == 2)
    {
        int i;
        for (i = 0; i < nN; ++i)
        {
            scanf("%d", &nNum[i]);
        }
        Monoque minQ;
        Monoque maxQ;

        for (i = 0; i < nK; ++i)
        {
            minQ.Insert(Small(nNum[i], i));
        }

        for (i = 0; i < nN - nK; ++i)
        {
            printf("%d ", minQ.Top());
            minQ.Insert(Small(nNum[i + nK], i + nK));
            minQ.Del(i + 1, i + nK);
        }
        printf("%d\n", minQ.Top());

        for (i = 0; i < nK; ++i)
        {
            maxQ.Insert(Big(nNum[i], i));
        }

        for (i = 0; i < nN - nK; ++i)
        {
            printf("%d ", maxQ.Top());
            maxQ.Insert(Big(nNum[i + nK], i + nK));
            maxQ.Del(i + 1, i + nK);
        }
        printf("%d\n", maxQ.Top());
    }

    return 0;
}

yx 2012-09-02 14:25 发表评论

hdu 3627 Giant For

yx — Thu, 26 Jul 2012 04:22:00 GMT

这个题是对可排序数据的实时增加删除查找，那天做比赛的时候一点都不会，想来想去觉得平衡树可以做，但是写平衡树是件很难的事情。
后面知道线段数可以做，虽然数据的范围很大，但是可以在全部读入数据后排序再离散化，然后进行线段树的操作，具体的代码没有写。
今天队友在网上发现一种用map和set可以水掉这题的方法。原来，这个方法最主要的使用了map和set里面的upper_bound操作，以前
居然忘记了这个东西了。既然这样，map和set也可以查前驱和后继了，但是注意low_bound查到的是小于等于的键。这个代码，注意是用
了一个map< int, set > 集合把坐标都存起来了，进行添加删除和查找后继的操作。由于查找需要查找的元素是既比x大又比y大的元
素，就比较麻烦，需要循环x往后查找，但是这样就无情的超时了。然后，有一个优化，记录y的数目，那么当出现很大的y的时候，就不需要
查找了，然后才过了这个题。但是，数据变成很大的y对应的x很小的话，那么绝对过不了这个题了，只能用线段树做了。
现在觉得用map和set查找前驱和后继确实能水掉一些题啊。

代码如下：

#include
#include <set>
#include
using namespace std;

map< int, set<int> > ms;//存储x,y
map< int, set<int> >::iterator it;
map<int, int> my;//存储y的数目
set<int>::iterator msit;
int main()
{
    int nN;
    int nCase = 1;
    char szCmd[10];
    int nX, nY;
    int nTemp;

    while(scanf("%d", &nN), nN)
    {
        if (nCase > 1)
        {
            printf("\n");
        }

        printf("Case %d:\n", nCase++);
        ms.clear();
        my.clear();
        while (nN--)
        {
            scanf("%s", szCmd);
            scanf("%d%d", &nX, &nY);
            if (szCmd[0] == 'a')
            {
                if (my.find(nY) == my.end())
                {
                    my[nY] = 1;
                }
                else
                {
                    my[nY]++;
                }

                if (ms.find(nX) == ms.end())
                {
                    ms[nX].insert(nY);
                }
                else
                {
                    msit = ms[nX].find(nY);
                    if (msit == ms[nX].end())//会出现重复的数据
                    {
                        ms[nX].insert(nY);
                    }
                }
            }
            else if (szCmd[0] == 'r')
            {
                ms[nX].erase(nY);
                if(ms[nX].size() == 0)
                {
                    ms.erase(nX);
                }
                my[nY]--;
                if (my[nY] == 0)
                {
                    my.erase(nY);
                }
            }
            else if (szCmd[0] == 'f')
            {
                if (my.upper_bound(nY) == my.end())
                {
                    printf("-1\n");
                    continue;
                }
                while (true)
                {
                    it = ms.upper_bound(nX);
                    if (it == ms.end())//比nX大的不存在
                    {
                        printf("-1\n");
                        break;
                    }
                    nTemp = it->first;
                    msit = ms[nTemp].upper_bound(nY);
                    if (msit == ms[nTemp].end())//比nY大的不存在
                    {
                        nX = nTemp;
                        continue;//那么增加x,继续往后查
                    }
                    else
                    {
                        printf("%d %d\n", nTemp, *msit);
                        break;
                    }
                }
            }
        }
    }

    return 0;
}

yx 2012-07-26 12:22 发表评论

uva 10562 - Undraw the Trees

yx — Tue, 10 Jul 2012 13:35:00 GMT

这是一个貌似很麻烦的题，题目要求是将一颗用ascii码绘画出来的树，转换为其一种字符串表示，这种字符串表示好像是叫做什么广义表
什么的。
比如，
A

--------

B C D

| |

----- -

E F G 对应的字符串表示 (A(B()C(E()F())D(G())))

比较纠结的是如何读取数据，如何递归，如果建立树的话，也麻烦，因为还是颗不定叉的树。最主要的是如何方便地递归。最后知道了一个
比较巧妙的方法，先一次性把一组数据读入字符串数组里面，再在这个字符串数组上进行递归处理。这样的话，就能很方便的找到树里面节点
的关系了。
而一次读一个字符就想进行递归是没办法确定节点的关系的，不递归估计更很难写，完全没头绪。。。

代码如下：

1 #include
2 #include <string.h>
3
4 char szLines[210][210];
5 int nNumOfLine;
6
7 void GetAns(int i, int j)
8 {
9     //printf("i:%d, j:%d, %c\n", i, j, szLines[i][j]);
10
11     if (szLines[i][j] != '\0')
12     {
13         putchar(szLines[i][j]);
14         //printf("%c", szLines[i + 1][j]);
15         if (szLines[i + 1][j] == '|')
16         {
17             int nBeg, nEnd;
18             nBeg = nEnd = j;
19             while (nBeg >= 0 && szLines[i + 2][nBeg] == '-')
20             {
21                 --nBeg;
22             }
23             while (szLines[i + 2][nEnd] == '-')
24             {
25                 ++nEnd;
26             }
27             //printf("nBeg:%d, nEnd:%d\n", nBeg, nEnd);
28             putchar('(');
29             for (int k = nBeg; k <= nEnd; ++k)
30             {
31                 if (szLines[i + 3][k] != ' ' && szLines[i + 3][k] != '\0')
32                 {
33                     GetAns(i + 3, k);
34                 }
35             }
36             putchar(')');
37         }
38         else
39         {
40             printf("()");
41         }
42     }
43
44 }
45
46 int main()
47 {
48     int nN;
49     char ch;
50
51     scanf("%d", &nN);
52     getchar();
53     while (nN--)
54     {
55         nNumOfLine = 0;
56         memset(szLines, 0, sizeof(szLines));
57         while (gets(szLines[nNumOfLine]), szLines[nNumOfLine][0] != '#')
58         {
59             //printf("%s\n", szLines[nNumOfLine]);
60             nNumOfLine++;
61         }
62         if (nNumOfLine == 0)
63         {
64             printf("()\n");
65             continue;
66         }
67         int i, j;
68         i = 0;
69         for (j = 0; szLines[0][j] == ' '; ++j);
70         //printf("i:%d, j:%d\n", i, j);
71         putchar('(');
72         GetAns(i, j);
73         putchar(')');
74         putchar('\n');
75     }
76
77     return 0;
78 }
79

yx 2012-07-10 21:35 发表评论

uva 327 - Evaluating Simple C Expressions

yx — Tue, 10 Jul 2012 04:05:00 GMT

这个题目的意思是要计算一些c语言表达式的值。这些表达式有+-还有++，--操作符与a-z这些变量组合而成。a-z的权值是1-26。
比如，表达式 c+f--+--a，得出值是9，其它变量的值也需要计算出来。
这个题目感觉比较麻烦，刚开始一点思路也没有，还写了个错误的方法，浪费了时间。
后面我的思路是（+，-）（--，++）（变量）（--，++），这个匹配式子的意思是先处理二元操作符，然后处理前置，再处理变量，
再处理后置，如果发现没有后置操作符，则把读取的数据重新写回数据流里面，下次再处理。

代码如下：

  1 #include
2 #include <string.h>
  3 #include
  4 #include
  5 using namespace std;
  6 struct INFO
  7 {
  8     char ch;
  9     int nValue;
10     char chAdd;
11     bool operator < (const INFO& info) const
12     {
13         return ch < info.ch;
14     }
15 };
16
17 INFO infos[200];
18 char szLine[200];
19
20 bool GetNextChar(stringstream& ss, char& ch)
21 {
22     while (ss >> ch)
23     {
24         if (ch != ' ');
25         {
26             return true;
27         }
28     }
29     return false;
30 }
31
32 int main()
33 {
34     while (gets(szLine))
35     {
36         printf("Expression: %s\n", szLine);
37         memset(infos, 0, sizeof(infos));
38         stringstream ss(szLine);
39         char ch;
40         int nNum = 0;
41         int nValue = 0;
42         char chOper;
43         bool bOk = true;
44         bool bFirst = true;
45         while (1)
46         {
47             if (bFirst)
48             {
49                 chOper = '+';
50                 bFirst = false;
51             }
52             else
53             {
54                 bOk = GetNextChar(ss, ch);
55                 if (!bOk) break;
56                 chOper = ch;
57             }
58
59             bOk = GetNextChar(ss, ch);
60             if (!bOk) break;
61
62             if (ch == '-')//前置--
63             {
64                 bOk = GetNextChar(ss, ch);
65                 if (!bOk) break;//-
66                 bOk = GetNextChar(ss, ch);
67                 if (!bOk) break;//读取字母
68
69                 infos[nNum].ch = ch;
70                 infos[nNum].nValue = ch - 'a';
71
72                 if (chOper == '+')
73                 {
74                     nValue += infos[nNum].nValue;
75                 }
76                 else
77                 {
78                     nValue -= infos[nNum].nValue;
79                 }
80                 ++nNum;
81             }
82             else if (ch == '+')//前置++
83             {
84                 bOk = GetNextChar(ss, ch);
85                 if (!bOk) break;//+
86                 bOk = GetNextChar(ss, ch);
87                 if (!bOk) break;//读取字母
88
89                 infos[nNum].ch = ch;
90                 infos[nNum].nValue = ch - 'a' + 2;
91
92                 if (chOper == '+')
93                 {
94                     nValue += infos[nNum].nValue;
95                 }
96                 else
97                 {
98                     nValue -= infos[nNum].nValue;
99                 }
100                 ++nNum;
101             }
102             else
103             {
104                 infos[nNum].ch = ch;
105                 infos[nNum].nValue = ch - 'a' + 1;
106
107                 if (chOper == '+')
108                 {
109                     nValue += infos[nNum].nValue;
110                 }
111                 else
112                 {
113                     nValue -= infos[nNum].nValue;
114                 }
115
116                 //读取后置操作符
117                 char chOne;
118                 char chTwo;
119                 bOk = GetNextChar(ss, chOne);
120                 if (!bOk)
121                 {
122                     ++nNum;
123                     break;
124                 }
125                 bOk = GetNextChar(ss, chTwo);
126                 if (!bOk)
127                 {
128                     ++nNum;
129                     break;
130                 }
131
132                 if (chOne == chTwo)
133                 {
134                     if (chOne == '+')
135                     {
136                         infos[nNum].chAdd = '+';
137                     }
138                     else
139                     {
140                         infos[nNum].chAdd = '-';
141                     }
142                 }
143                 else
144                 {
145                     ss.putback(chTwo);
146                     ss.putback(chOne);
147                 }
148                 ++nNum;
149             }
150         }
151
152         printf("    value = %d\n", nValue);
153         sort(infos, infos + nNum);
154         for (int i = 0; i < nNum; ++i)
155         {
156             if (infos[i].chAdd == '+')
157             {
158                 infos[i].nValue++;
159             }
160             else if (infos[i].chAdd == '-')
161             {
162                 infos[i].nValue--;
163             }
164             printf("    %c = %d\n", infos[i].ch, infos[i].nValue);
165         }
166     }
167
168     return 0;
169 }
170

yx 2012-07-10 12:05 发表评论

uva 297 - Quadtrees

yx — Sun, 08 Jul 2012 03:06:00 GMT

题意是用字符串描述的一棵四叉树，读取字符串获得最终叶子节点的颜色。输入是2个字符串，根据这2个字符串建立2个四叉树。然后对于，指定位置的叶子节点，如果2颗树的叶子颜色其中一个为黑色，那么ans++，输出的就是ans。
类似树形结构的东西，直接一个函数递归求解即可。函数参数，一般是字符串地址，当前位置，然后还有其它在递归时候需要用到的东西。

代码如下：

1 #include
2 #define BLACK (1)
3 #define WHITE (2)
4 #define MAX (32)
5 int nStateA[MAX][MAX];
6 int nStateB[MAX][MAX];
7
8 char szOne[10000];
9 char szTwo[10000];
10
11 void GetState(int nState[MAX][MAX], char* pszLine, int& nPos,
12               int nSize, int nX, int nY)
13 {
14     if (pszLine[nPos] == 'p')
15     {
16         ++nPos;
17         GetState(nState, pszLine, nPos, nSize / 2, nX + nSize / 2, nY);
18         GetState(nState, pszLine, nPos, nSize / 2, nX, nY);
19         GetState(nState, pszLine, nPos, nSize / 2, nX, nY + nSize / 2);
20         GetState(nState, pszLine, nPos, nSize / 2, nX + nSize / 2, nY + nSize / 2);
21     }
22     else
23     {
24         for (int i = nX; i < nX + nSize; ++i)
25         {
26             for (int j = nY; j < nY + nSize; ++j)
27             {
28                 if (pszLine[nPos] == 'e')
29                 {
30
31                     nState[i][j] = WHITE;
32                 }
33                 else
34                 {
35                     nState[i][j] = BLACK;
36                 }
37             }
38         }
39         ++nPos;
40     }
41 }
42
43 int main()
44 {
45     int nCases;
46
47     scanf("%d\n", &nCases);
48     while (nCases--)
49     {
50         gets(szOne);
51         gets(szTwo);
52         int nPos = 0;
53         GetState(nStateA, szOne, nPos, MAX, 0, 0);
54         nPos = 0;
55         GetState(nStateB, szTwo, nPos, MAX, 0, 0);
56         int nAns = 0;
57
58         for (int i = 0; i < MAX; ++i)
59         {
60             for (int j = 0; j < MAX; ++j)
61             {
62                 if (nStateA[i][j] == BLACK || nStateB[i][j] == BLACK)
63                 {
64                     nAns++;
65                 }
66             }
67         }
68         printf("There are %d black pixels.\n", nAns);
69     }
70
71     return 0;
72 }
73

yx 2012-07-08 11:06 发表评论

无穷大数组上如何直接寻址来实现字典？

yx — Tue, 20 Mar 2012 11:26:00 GMT

这是算法导论习题11.1-4。
具体题目如下：


解决该题目的要点：
1.由于是无穷大的数组，所以无法事先初始化该数组。
2.所提供的方案必须是O（1）。
3.使用的额外空间只能是O（n），这样平均到每一个项上的空间都是O（1）。

一时之间好像没有一点头绪，在几个群里面发问了，网上搜了很久也没有找到答案，后面一群里有个高人给了个链接，里面有解法。
链接地址：http://www.cnblogs.com/flyfy1/archive/2011/03/05/1971502.html，这篇文章里面另外给了个pdf，这个pdf估计是解法
的来源。伪代码写得不给力，不过前面的英文描述却很清晰。说实话，这个方法很巧妙。

解法大概的意思如下：
   开一个额外的数组A，A[0]表示A数组元素的数目(当然不包括A[0]本身)，A[i]代表插入的第i个元素的key。假设原来的无穷大数组用Huge
表示，如果Huge[i](直接寻址，假设i就是key)有效，则表示其在A数组中的索引。那么如果A[Huge[i]] == i 而且 Huge[i] <= A[0] &&
Huge[i] > 0，则表示i这个位置已经有元素插入了。

插入：A[0]++;A[A[0]] = key; Huge[key] = A[0];
搜索: A[Huge[i]] == i && Huge[i] <= A[0] && Huge[i] > 0 则return true;
删除: 先搜索该位置是否有元素, 如果Search(key)成功，则先把Huge[ A[A[0]] ] = Huge[key]，
            然后交换A[A[0]]和A[Huge[key]]，A[0]--即可。
所有操作都是O（1），平均到每一个项，使用的空间都是O（1）。

我用代码实现的模拟如下：

#include
#include
#include
using std::swap;
using std::vector;
#define INF (100)

int nHuge[INF];//假设这个巨大的数组是无法初始化的
vector<int> vA;

void Init()
{
    vA.push_back(0);//添加A[0]表示元素的数目
}

void Insert(int nKey)
{
    vA[0]++;
    nHuge[nKey] = vA[0];
    vA.push_back(nKey);
}

bool Search(int nKey)
{
    if (nHuge[nKey] > 0 && nHuge[nKey] <= vA[0] && vA[nHuge[nKey]] == nKey)
    {
        return true;
    }

    return false;
}

void Delete(int nKey)
{
    if (Search(nKey))
    {
        nHuge[ vA[vA[0]] ] = nHuge[nKey];//将huge的最后一个元素中存储的A数组的索引改为nHuge[nKey]
        swap(vA[vA[0]], vA[nHuge[nKey]]);//交换key
        --vA[0];

vA.erase(vA.end() - 1);

    }
}

#define MAX (10)
int main()
{
    Init();
    int i;
    for (i = 0; i < MAX; ++i)
    {
        Insert(i);
    }
    for (i = 0; i < MAX; ++i)
    {
        printf("Search:%d %s\n", i, Search(i) == true? "Success" : "Failure");
    }
    printf("\n");

    Delete(4);
    Delete(9);
    Delete(1);
    for (i = 0; i < MAX * 2; ++i)
    {
        printf("Search:%d %s\n", i, Search(i) == true? "Success" : "Failure");
    }

    return 0;
}

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

两个栈实现一个队列和两个队列实现一个栈

yx — Sun, 11 Mar 2012 12:30:00 GMT

两个栈实现一个队列
   要求：只能使用栈的pop和push，以及测试栈是否为空三个操作。
实现思路：
      队列里面使用stack one 和 stack two。
      进队列时，直接进入栈one即可。
      出队列时，从two弹出一个元素，如果two里面的元素为空，则将one里面的元素依次弹出并压入two中，再从two弹出一个元素返回。

   用STL里面的stack模拟实现queue的代码如下：
1 #include <stdio.h>

  2 #include
  3 #include
  4 #include
  5 using std::stack;
  6
  7 template<class T> class CQueue
  8 {
  9 public:
10     CQueue()
11     {
12         nSize = 0;
13     }
14
15     void clear()
16     {
17         while (!one.empty())
18         {
19             one.pop();
20         }
21         while (!two.empty())
22         {
23             two.pop();
24         }
25     }
26
27     void push(const T& t)
28     {
29         one.push(t);
30         ++nSize;
31     }
32
33     void pop()
34     {
35         if (two.empty())
36         {
37             while (!one.empty())
38             {
39                 two.push(one.top());
40                 one.pop();
41             }
42         }
43         two.pop();
44         --nSize;
45     }
46
47     T& front()
48     {
49         if (two.empty())
50         {
51             while (!one.empty())
52             {
53                 two.push(one.top());
54                 one.pop();
55             }
56         }
57         return two.top();
58     }
59
60     T& back()
61     {
62         return one.top();
63     }
64
65     bool empty()
66     {
67         return nSize == 0;
68     }
69
70 private:
71     stack one;
72     stack two;
73     int nSize;
74 };
75
76 #define MAX 20
77
78 int main()
79 {
80     CQueue<int> q;
81
82     srand(time(NULL));
83     for (int i = 0; i < MAX; ++i)
84     {
85         q.push(i);
86
87         if (rand() % 2)
88         {
89             printf("front: %d\n", q.front());
90             q.pop();
91         }
92     }
93
94     while (!q.empty())
95     {
96         printf("front: %d\n", q.front());
97         q.pop();
98     }
99
100     return 0;
101 }
102

两个队列实现一个栈
   要求：只能使用从队列的尾部入和头部出，以及测试队列是否为空三个操作。
实现思路：
      队列里面使用queue one 和 stack two。
      进栈时，根据当前元素是全部存储在哪个队列而选择从one或者two的尾部进入。
出栈时，假设当前元素都存储在one里面，则不断出队列，直到队列为空之前的所有元素一次进入队列two，而one里面的最后一个元素
      作为栈弹出的值返回。
对于当前元素是存储在哪个队列里面，可以设置变量标记，初始化时候存储在one里面，操作一次，由于元素要倒转，则存储位置会变
      一次。

用STL里面的queue模拟实现的stack代码如下：
1 #include <stdio.h>

  2 #include
  3 using std::queue;
  4
  5 template<class T> class CStack
  6 {
  7 public:
  8     CStack()
  9     {
10         nSize = 0;
11         nTime = 1;
12     }
13
14     void clear()
15     {
16         while (!one.empty())
17         {
18             one.pop();
19         }
20         while (!two.empty())
21         {
22             two.pop();
23         }
24     }
25
26     void push(const T& t)
27     {
28         if (nTime % 2)
29         {
30             one.push(t);
31         }
32         else
33         {
34             two.push(t);
35         }
36         ++nSize;
37     }
38
39     void pop()
40     {
41         if (nTime % 2)
42         {
43             while (!one.empty())
44             {
45                 T t = one.front();
46                 one.pop();
47                 if (!one.empty())
48                 {
49                     two.push(t);
50                 }
51             }
52         }
53         else
54         {
55             while (!two.empty())
56             {
57                 T t = two.front();
58                 two.pop();
59                 if (!two.empty())
60                 {
61                     one.push(t);
62                 }
63             }
64         }
65
66         nTime = (nTime + 1) % 2;
67         --nSize;
68     }
69
70     T& top()
71     {
72         if (nTime % 2)
73         {
74             while (!one.empty())
75             {
76                 T t = one.front();
77                 one.pop();
78                 if (!one.empty())
79                 {
80                     two.push(t);
81                 }
82                 else
83                 {
84                     two.push(t);
85                     nTime = (nTime + 1) % 2;
86                     return two.back();
87                 }
88             }
89         }
90         else
91         {
92             while (!two.empty())
93             {
94                 T t = two.front();
95                 two.pop();
96                 if (!two.empty())
97                 {
98                     one.push(t);
99                 }
100                 else
101                 {
102                     one.push(t);
103                     nTime = (nTime + 1) % 2;
104                     return one.back();
105                 }
106             }
107         }
108     }
109
110     bool empty()
111     {
112         return nSize == 0;
113     }
114
115 private:
116     queue one;
117     queue two;
118     int nSize;
119     int nTime;
120 };
121
122 #define MAX 20
123
124 int main()
125 {
126     CStack<int> stack;
127
128     for (int i = 0; i < MAX; ++i)
129     {
130         stack.push(i);
131     }
132
133     while (!stack.empty())
134     {
135         printf("top: %d\n", stack.top());
136         stack.pop();
137     }
138
139     return 0;
140 }
141

yx 2012-03-11 20:30 发表评论

POJ百练 - 2797:最短前缀(可以使用字典树做)

yx — Tue, 22 Nov 2011 07:11:00 GMT

链接: http://poj.grids.cn/practice/2797/

这题乍看之下确实没什么思路,后面终于明白题意了,然后突然想到可以用字典树做,速度当然会是非常快的...
但是其实还有一种更简单的方法,那就是对所有字符串排序之后,每个字符串的前缀长度其实就是由其前一个和后一个字符串共同决定,
nLen = max(nOne, nTwo), nOne 和 nTwo就分别代表当前字符串和前后字符串公告部分的长度+1后的值...
代码写出来写非常简单...同学这样实现了下,也轻松过了...

然后我就辛苦的写了一棵字典树...可能我的写法不是很标准,因为我没参考什么模板,自己硬想出来怎么写的...
我的想法是开一个静态大数组,第一个结点作为根,不存储数据,从第二个结点开始作为自由空间分配...
其实,就是对26颗字典树虚拟了个无数据的根结点...
使用了虚拟的根结点后,代码比用26个根结点简洁很多...
刚开始我就假设1-26号结点分别为a-z,作为26颗树的根,
而且下26个结点的位置我用的是索引,没用指针,后面换成了指针,代码看起来更舒服了...

#include

#define LETTER_NUM 26

#define WORD_LEN_MAX 25

#define WORD_NUM_MAX 1030

#define NODE_MAX (WORD_LEN_MAX * WORD_NUM_MAX + 10)

struct WORD_TREE

{

char ch;

WORD_TREE* next[LETTER_NUM];

int nTime;

};

WORD_TREE tree[NODE_MAX];

WORD_TREE* pFreeNode = tree + 1;//第一个结点作为头结点,不存储数据

char szWords[WORD_NUM_MAX][WORD_LEN_MAX];

void AddToTree(char* pszStr)

{

WORD_TREE* pTree = tree;

while (*pszStr && pTree->next[*pszStr - 'a'])

{

pTree = pTree->next[*pszStr - 'a'];

pTree->nTime++;

++pszStr;

}

while (*pszStr)

{

pFreeNode->ch = *pszStr;

pFreeNode->nTime++;

pTree->next[*pszStr - 'a'] = pFreeNode;

pTree = pFreeNode;

++pszStr;

++pFreeNode;

}

int FindPrefix(char* pszStr)

{

WORD_TREE* pTree = tree;

int nLen = 0;

while (*pszStr)

{

++nLen;

pTree = pTree->next[*pszStr - 'a'];

if (pTree->nTime <= 1)

{

break;

}

++pszStr;

}

return nLen;

}

int main()

{

int nCount = 0;

while (scanf("%s", szWords[nCount]) != EOF)

{

AddToTree(szWords[nCount]);

nCount++;

}

for (int i = 0; i < nCount; ++i)

{

int nLen = FindPrefix(szWords[i]);

printf("%s ", szWords[i]);

for (int j = 0; j < nLen; ++j)

{

putchar(szWords[i][j]);

}

putchar('\n');

}

return 0;

}

yx 2011-11-22 15:11 发表评论

C++博客-yx-随笔分类-数据结构

poj 3264 Balanced Lineup St算法建立Rmq

poj 3764 The xor-longest Path 字典树 + Xor

poj 1182 食物链 并查集

poj 1988 Cube Stacking 并查集

poj 1984 Navigation Nightmare 并查集

poj 1703 Find them, Catch them 并查集

poj 3468 A Simple Problem with Integers 线段树成段延迟更新

poj 2886 Who Gets the Most Candies? 约瑟夫环和反素数

hdu 2492 Ping pong 树状数组

hdu 3584 Cube 三维树状数组

hdu 1556 Color the ball 树状数组

poj 2823 Sliding Window 单调队列

hdu 3627 Giant For

uva 10562 - Undraw the Trees

uva 327 - Evaluating Simple C Expressions

uva 297 - Quadtrees

无穷大数组上如何直接寻址来实现字典？

两个栈实现一个队列 和 两个队列实现一个栈

POJ百练 - 2797:最短前缀(可以使用字典树做)

poj 1182 食物链并查集

两个栈实现一个队列和两个队列实现一个栈